From 77461541c237f97f3b45a5db816fc8759d25aa75 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 7 Mar 2018 11:29:11 +0900 Subject: [PATCH 01/16] package version up to 1.16.0 Change-Id: I4c0c3ba7a7e7fc5ca7b8d618bc873e4d61df53dd --- configure.ac | 2 +- doc/tdm_doc.h | 2 +- packaging/libtdm.spec | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/configure.ac b/configure.ac index 04bf549..1829d04 100644 --- a/configure.ac +++ b/configure.ac @@ -1,7 +1,7 @@ AC_PREREQ([2.60]) m4_define([tdm_major_version], [1]) -m4_define([tdm_minor_version], [15]) +m4_define([tdm_minor_version], [16]) m4_define([tdm_micro_version], [0]) m4_define([tdm_version], [tdm_major_version.tdm_minor_version.tdm_micro_version]) diff --git a/doc/tdm_doc.h b/doc/tdm_doc.h index d11256f..b7e3529 100644 --- a/doc/tdm_doc.h +++ b/doc/tdm_doc.h @@ -39,7 +39,7 @@ /** * @mainpage TDM * @author Boram Park, boram1288.park@samsung.com - * @version 1.15.0 + * @version 1.16.0 * @par Introduction * TDM stands for Tizen Display Manager. It's the display HAL layer for tizen * display server. It offers the frontend APIs(@ref tdm.h) for a frontend user diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index 9ca1257..2abebe3 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -2,7 +2,7 @@ %define UTEST_GCOV 0 Name: libtdm -Version: 1.15.1 +Version: 1.16.0 Release: 0 Summary: User Library of Tizen Display Manager Group: Development/Libraries -- 2.7.4 From a5be69dc815078b1132eb3291d56cd7ddb85a412 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Thu, 8 Mar 2018 15:39:18 +0900 Subject: [PATCH 02/16] output: add debugging log Change-Id: I0dd4ef4067e18706257619a1cfb2f6dea79f0657 --- src/tdm_output.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/tdm_output.c b/src/tdm_output.c index 15ebd81..b846354 100644 --- a/src/tdm_output.c +++ b/src/tdm_output.c @@ -766,6 +766,9 @@ _tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence, vblank_handler->sent_to_frontend = 1; + if (tdm_debug_module & TDM_DEBUG_COMMIT) + TDM_INFO("output(%d) wait_vblank: handler(%p)", vblank_handler->private_output->pipe, vblank_handler); + ret = tdm_thread_cb_call(vblank_handler->private_output, &output_vblank.base); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } -- 2.7.4 From 1ffe57e554823b255a379390e220eac050417e5a Mon Sep 17 00:00:00 2001 From: Boram Park Date: Thu, 8 Mar 2018 15:39:37 +0900 Subject: [PATCH 03/16] utests: add more tc Change-Id: I304f08c9f390acdfd4a7935be4a404afaa6e6c63 --- utests/src/ut_tdm_output.cpp | 22 ++++++++++++++++++++++ utests/src/ut_tdm_vblank.cpp | 27 +++++++++++++++++++++++++++ 2 files changed, 49 insertions(+) diff --git a/utests/src/ut_tdm_output.cpp b/utests/src/ut_tdm_output.cpp index 4556178..e543a55 100644 --- a/utests/src/ut_tdm_output.cpp +++ b/utests/src/ut_tdm_output.cpp @@ -1334,6 +1334,28 @@ TEST_P(TDMOutput, OutputWaitVblankFewTimesInOneVblank) } } +TEST_P(TDMOutput, OutputWaitVblankBeforeDpmsOff) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + for (int o = 0; o < output_count; o++) { + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + + for (int t = 0; t < 10; t++) { + bool done = false; + + ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], 1, 0, _ut_tdm_output_done_cb, &done) == TDM_ERROR_NONE); + if (t == 9) + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + while(!done) + ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + } + } +} + TEST_P(TDMOutput, OutputRemoveVblankHandler) { TDM_UT_SKIP_FLAG(has_outputs); diff --git a/utests/src/ut_tdm_vblank.cpp b/utests/src/ut_tdm_vblank.cpp index a4d9f8b..3b3e8e3 100644 --- a/utests/src/ut_tdm_vblank.cpp +++ b/utests/src/ut_tdm_vblank.cpp @@ -1126,6 +1126,33 @@ TEST_P(TDMVblank, VblankWaitDpmsOff) } } +TEST_P(TDMVblank, VblankWaitBeforeDpmsOff) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + ASSERT_TRUE(TestPrepareOutput() == true); + ASSERT_TRUE(TestCreateVblanks() == true); + + for (int v = 0; v < vblank_count; v++) { + unsigned int temp = 0; + tdm_error ret; + tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + + if (!ut_tdm_output_is_connected(output)) + continue; + + ASSERT_TRUE(ut_tdm_output_unset(dpy, output) == true); + + ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &temp) == TDM_ERROR_NONE); + + ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + + while (temp == 0) + ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + } +} + TEST_P(TDMVblank, VblankWaitSetEnableFakeDpmsOff) { TDM_UT_SKIP_FLAG(has_outputs); -- 2.7.4 From 7941cfbc65a4abcdc1e9c45716e0561348b0ed2a Mon Sep 17 00:00:00 2001 From: Boram Park Date: Thu, 8 Mar 2018 21:35:07 +0900 Subject: [PATCH 04/16] thread: checking waiting cb_type if waiting_cb_type != cb_type->type, send cb to other thread if needed. when a thread is waiting status, if other thread tries to send the same type cb as sync, we CAN'T handle it. So we'd better make assert it to find another solution. Change-Id: I06f92b2814a3a4e0d23d9d6df3c8b17526e1175f --- src/tdm_thread.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/tdm_thread.c b/src/tdm_thread.c index db910c2..ca59103 100644 --- a/src/tdm_thread.c +++ b/src/tdm_thread.c @@ -613,6 +613,7 @@ tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) struct list_head *list, *other_list; struct list_head call_list; static pid_t waiting_tid = 0; + static tdm_thread_cb_type waiting_cb_type = TDM_THREAD_CB_NONE; tdm_error ret; TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED); @@ -626,6 +627,10 @@ tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) assert(find_funcs[cb_base->type] != NULL); + /* When there is the previous waiting sync call, the other type sync call CAN't be handlered */ + if (waiting_tid > 0 && cb_base->sync == 1) + assert(waiting_cb_type == cb_base->type); + if (!object) { object = find_funcs[cb_base->type](private_display, cb_base->object_stamp); if (!object) { @@ -670,7 +675,7 @@ tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) assert(LIST_IS_EMPTY(&call_list)); - if (waiting_tid == 0) { + if (waiting_tid == 0 || waiting_cb_type != cb_base->type) { LIST_FOR_EACH_ENTRY_SAFE(cb, hh, other_list, link) { if (cb->object != object || cb->cb_type != cb_base->type || @@ -686,6 +691,7 @@ tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) if (keep_private_thread) { if (cb_base->sync) { waiting_tid = 0; + waiting_cb_type = TDM_THREAD_CB_NONE; pthread_cond_signal(&keep_private_thread->event_cond); if (tdm_debug_module & TDM_DEBUG_THREAD) TDM_INFO("pthread broadcase"); @@ -712,6 +718,8 @@ tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) */ tdm_mutex_locked = 0; waiting_tid = caller_tid; + waiting_cb_type = cb_base->type; + pthread_cond_wait(&keep_private_thread->event_cond, &private_display->lock); tdm_mutex_locked = 1; } -- 2.7.4 From 11b7cf91cd5f44d381bab1e6d5659b9da261a82a Mon Sep 17 00:00:00 2001 From: Boram Park Date: Thu, 8 Mar 2018 21:41:20 +0900 Subject: [PATCH 05/16] package version up to 1.16.1 Change-Id: I2ce18aa2791e733216d174f791cf190fe6d486f1 --- packaging/libtdm.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index 2abebe3..62b46e8 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -2,7 +2,7 @@ %define UTEST_GCOV 0 Name: libtdm -Version: 1.16.0 +Version: 1.16.1 Release: 0 Summary: User Library of Tizen Display Manager Group: Development/Libraries -- 2.7.4 From dd84f199e0e855ca945bae239c152fa22147af53 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Mon, 12 Mar 2018 17:13:03 +0900 Subject: [PATCH 06/16] output: seperate output-status and output-dpms change Change-Id: I0fabb65405347dab1f8604827df00be274410091 --- src/tdm.c | 3 +- src/tdm_macro.h | 3 +- src/tdm_output.c | 98 ++++++++++++++++++++++++++++++++++--------------- src/tdm_private_types.h | 16 +++++--- src/tdm_thread.c | 13 ++++--- 5 files changed, 91 insertions(+), 42 deletions(-) diff --git a/src/tdm.c b/src/tdm.c index fca53dd..7d80016 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -194,7 +194,8 @@ _tdm_display_destroy_private_output(tdm_private_output *private_output) LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list, link) { LIST_DEL(&h->link); - tdm_thread_cb_remove(h->private_output, TDM_THREAD_CB_OUTPUT_CHANGE, NULL, tdm_output_thread_cb_change, h); + tdm_thread_cb_remove(h->private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, h); + tdm_thread_cb_remove(h->private_output, TDM_THREAD_CB_OUTPUT_STATUS, NULL, tdm_output_thread_cb_change, h); free(h); } diff --git a/src/tdm_macro.h b/src/tdm_macro.h index e681337..80be131 100644 --- a/src/tdm_macro.h +++ b/src/tdm_macro.h @@ -244,7 +244,8 @@ static struct tdm_type_name tdm_cb_type_names[] = { { TDM_THREAD_CB_NONE, "none" }, { TDM_THREAD_CB_OUTPUT_COMMIT, "output-commit" }, { TDM_THREAD_CB_OUTPUT_VBLANK, "output-vblank" }, - { TDM_THREAD_CB_OUTPUT_CHANGE, "output-change" }, + { TDM_THREAD_CB_OUTPUT_STATUS, "output-status" }, + { TDM_THREAD_CB_OUTPUT_DPMS, "output-dpms" }, { TDM_THREAD_CB_PP_DONE, "pp-done" }, { TDM_THREAD_CB_CAPTURE_DONE, "capture-done" }, { TDM_THREAD_CB_VBLANK_SW, "vblank-sw" }, diff --git a/src/tdm_output.c b/src/tdm_output.c index b846354..e6eed12 100644 --- a/src/tdm_output.c +++ b/src/tdm_output.c @@ -146,7 +146,9 @@ tdm_output_init(tdm_private_display *private_display) { tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_COMMIT, tdm_display_find_output_stamp); tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_VBLANK, tdm_display_find_output_stamp); - tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_CHANGE, tdm_display_find_output_stamp); + tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_STATUS, tdm_display_find_output_stamp); + tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_DPMS, tdm_display_find_output_stamp); + return TDM_ERROR_NONE; } @@ -226,34 +228,68 @@ INTERN void tdm_output_thread_cb_change(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data) { tdm_private_output *private_output = object; - tdm_thread_cb_output_change *output_change = (tdm_thread_cb_output_change *)cb_base; tdm_private_output_change_handler *change_handler = user_data; + tdm_output_change_type type = TDM_OUTPUT_CHANGE_CONNECTION; + tdm_value value = {.u32 = 0 }; TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED()); assert(change_handler->owner_tid == syscall(SYS_gettid)); + if (cb_base->type == TDM_THREAD_CB_OUTPUT_STATUS) { + tdm_thread_cb_output_status *output_status = (tdm_thread_cb_output_status *)cb_base; + type = TDM_OUTPUT_CHANGE_CONNECTION; + value.u32 = output_status->status; + } else if (cb_base->type == TDM_THREAD_CB_OUTPUT_DPMS) { + tdm_thread_cb_output_dpms *output_dpms = (tdm_thread_cb_output_dpms *)cb_base; + type = TDM_OUTPUT_CHANGE_DPMS; + value.u32 = output_dpms->dpms; + } else { + TDM_NEVER_GET_HERE(); + return; + } + _pthread_mutex_unlock(&private_display->lock); - change_handler->func(private_output, output_change->type, output_change->value, change_handler->user_data); + change_handler->func(private_output, type, value, change_handler->user_data); _pthread_mutex_lock(&private_display->lock); + } static tdm_error -_tdm_output_call_thread_cb_change(tdm_private_output *private_output, tdm_output_change_type type, tdm_value value) +_tdm_output_call_thread_cb_status(tdm_private_output *private_output, tdm_output_conn_status status) { - tdm_thread_cb_output_change output_change; + tdm_thread_cb_output_status output_status; tdm_error ret; - memset(&output_change, 0, sizeof output_change); - output_change.base.type = TDM_THREAD_CB_OUTPUT_CHANGE; - output_change.base.length = sizeof output_change; - output_change.base.object_stamp = private_output->stamp; - output_change.base.data = NULL; - output_change.base.sync = 1; - output_change.type = type; - output_change.value = value; + memset(&output_status, 0, sizeof output_status); + output_status.base.type = TDM_THREAD_CB_OUTPUT_STATUS; + output_status.base.length = sizeof output_status; + output_status.base.object_stamp = private_output->stamp; + output_status.base.data = NULL; + output_status.base.sync = 1; + output_status.status = status; - ret = tdm_thread_cb_call(private_output, &output_change.base); + ret = tdm_thread_cb_call(private_output, &output_status.base); + TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); + + return TDM_ERROR_NONE; +} + +static tdm_error +_tdm_output_call_thread_cb_dpms(tdm_private_output *private_output, tdm_output_dpms dpms) +{ + tdm_thread_cb_output_dpms output_dpms; + tdm_error ret; + + memset(&output_dpms, 0, sizeof output_dpms); + output_dpms.base.type = TDM_THREAD_CB_OUTPUT_DPMS; + output_dpms.base.length = sizeof output_dpms; + output_dpms.base.object_stamp = private_output->stamp; + output_dpms.base.data = NULL; + output_dpms.base.sync = 0; + output_dpms.dpms = dpms; + + ret = tdm_thread_cb_call(private_output, &output_dpms.base); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); return TDM_ERROR_NONE; @@ -263,7 +299,6 @@ INTERN void tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status, void *user_data) { tdm_private_output *private_output = user_data; - tdm_value value; tdm_error ret; TDM_RETURN_IF_FAIL(private_output); @@ -278,9 +313,7 @@ tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status, private_output->caps.status = status; } - value.u32 = status; - - ret = _tdm_output_call_thread_cb_change(private_output, TDM_OUTPUT_CHANGE_CONNECTION, value); + ret = _tdm_output_call_thread_cb_status(private_output, status); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } @@ -288,7 +321,6 @@ INTERN void tdm_output_cb_dpms(tdm_output *output_backend, tdm_output_dpms dpms, void *user_data) { tdm_private_output *private_output = user_data; - tdm_value value; tdm_error ret; TDM_INFO("output(%d) %s", private_output->pipe, tdm_status_str(dpms)); @@ -297,9 +329,7 @@ tdm_output_cb_dpms(tdm_output *output_backend, tdm_output_dpms dpms, void *user_ private_output->waiting_dpms_change = 0; TDM_INFO("output(%d) dpms async '%s' done", private_output->pipe, tdm_dpms_str(dpms)); - value.u32 = dpms; - - ret = _tdm_output_call_thread_cb_change(private_output, TDM_OUTPUT_CHANGE_DPMS, value); + ret = _tdm_output_call_thread_cb_dpms(private_output, dpms); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } @@ -332,10 +362,21 @@ tdm_output_add_change_handler(tdm_output *output, /* LCOV_EXCL_STOP */ } - ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_CHANGE, NULL, tdm_output_thread_cb_change, change_handler); + ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, change_handler); + if (ret != TDM_ERROR_NONE) { + /* LCOV_EXCL_START */ + TDM_ERR("tdm_thread_cb_add failed"); + free(change_handler); + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_OPERATION_FAILED; + /* LCOV_EXCL_STOP */ + } + + ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_STATUS, NULL, tdm_output_thread_cb_change, change_handler); if (ret != TDM_ERROR_NONE) { /* LCOV_EXCL_START */ TDM_ERR("tdm_thread_cb_add failed"); + tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, change_handler); free(change_handler); _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_OPERATION_FAILED; @@ -375,7 +416,8 @@ tdm_output_remove_change_handler(tdm_output *output, if (change_handler->func != func || change_handler->user_data != user_data) continue; - tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_CHANGE, NULL, tdm_output_thread_cb_change, change_handler); + tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, change_handler); + tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_STATUS, NULL, tdm_output_thread_cb_change, change_handler); LIST_DEL(&change_handler->link); free(change_handler); @@ -1304,10 +1346,8 @@ tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value) done: if (ret == TDM_ERROR_NONE) { if (private_output->current_dpms_value != dpms_value) { - tdm_value value; private_output->current_dpms_value = dpms_value; - value.u32 = dpms_value; - _tdm_output_call_thread_cb_change(private_output, TDM_OUTPUT_CHANGE_DPMS, value); + _tdm_output_call_thread_cb_dpms(private_output, dpms_value); TDM_INFO("output(%d) dpms '%s' done", private_output->pipe, tdm_dpms_str(dpms_value)); } } else { @@ -1448,13 +1488,11 @@ tdm_output_get_dpms_internal(tdm_output *output, tdm_output_dpms *dpms_value) /* checking with backend's value */ if (*dpms_value != private_output->current_dpms_value) { - tdm_value value; TDM_ERR("output(%d) dpms changed suddenly: %s -> %s", private_output->pipe, tdm_dpms_str(private_output->current_dpms_value), tdm_dpms_str(*dpms_value)); private_output->current_dpms_value = *dpms_value; - value.u32 = *dpms_value; - _tdm_output_call_thread_cb_change(private_output, TDM_OUTPUT_CHANGE_DPMS, value); + _tdm_output_call_thread_cb_dpms(private_output, *dpms_value); } return ret; diff --git a/src/tdm_private_types.h b/src/tdm_private_types.h index d1c132d..a5b4423 100644 --- a/src/tdm_private_types.h +++ b/src/tdm_private_types.h @@ -449,7 +449,8 @@ typedef enum { TDM_THREAD_CB_NONE, TDM_THREAD_CB_OUTPUT_COMMIT, TDM_THREAD_CB_OUTPUT_VBLANK, - TDM_THREAD_CB_OUTPUT_CHANGE, + TDM_THREAD_CB_OUTPUT_STATUS, + TDM_THREAD_CB_OUTPUT_DPMS, TDM_THREAD_CB_PP_DONE, TDM_THREAD_CB_CAPTURE_DONE, TDM_THREAD_CB_VBLANK_SW, @@ -461,7 +462,8 @@ typedef enum { typedef struct _tdm_thread_cb_base tdm_thread_cb_base; typedef struct _tdm_thread_cb_output_vblank tdm_thread_cb_output_commit; typedef struct _tdm_thread_cb_output_vblank tdm_thread_cb_output_vblank; -typedef struct _tdm_thread_cb_output_change tdm_thread_cb_output_change; +typedef struct _tdm_thread_cb_output_dpms tdm_thread_cb_output_dpms; +typedef struct _tdm_thread_cb_output_status tdm_thread_cb_output_status; typedef struct _tdm_thread_cb_pp_done tdm_thread_cb_pp_done; typedef struct _tdm_thread_cb_capture_done tdm_thread_cb_capture_done; typedef struct _tdm_thread_cb_vblank_sw tdm_thread_cb_vblank_sw; @@ -483,10 +485,14 @@ struct _tdm_thread_cb_output_vblank { unsigned int tv_usec; }; -struct _tdm_thread_cb_output_change { +struct _tdm_thread_cb_output_status { tdm_thread_cb_base base; - tdm_output_change_type type; - tdm_value value; + tdm_output_conn_status status; +}; + +struct _tdm_thread_cb_output_dpms { + tdm_thread_cb_base base; + tdm_output_dpms dpms; }; struct _tdm_thread_cb_pp_done { diff --git a/src/tdm_thread.c b/src/tdm_thread.c index ca59103..b183c59 100644 --- a/src/tdm_thread.c +++ b/src/tdm_thread.c @@ -437,7 +437,8 @@ tdm_thread_handle_cb(tdm_private_loop *private_loop) switch (base->type) { case TDM_THREAD_CB_OUTPUT_COMMIT: case TDM_THREAD_CB_OUTPUT_VBLANK: - case TDM_THREAD_CB_OUTPUT_CHANGE: + case TDM_THREAD_CB_OUTPUT_STATUS: + case TDM_THREAD_CB_OUTPUT_DPMS: case TDM_THREAD_CB_PP_DONE: case TDM_THREAD_CB_CAPTURE_DONE: case TDM_THREAD_CB_VBLANK_SW: @@ -620,16 +621,18 @@ tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) TDM_RETURN_VAL_IF_FAIL(cb_base != NULL, TDM_ERROR_INVALID_PARAMETER); TDM_RETURN_VAL_IF_FAIL(cb_base->type > 0, TDM_ERROR_INVALID_PARAMETER); TDM_RETURN_VAL_IF_FAIL(cb_base->length > 0, TDM_ERROR_INVALID_PARAMETER); - TDM_RETURN_VAL_IF_FAIL(cb_base->sync == 0 || cb_base->sync == 1, TDM_ERROR_INVALID_PARAMETER); TDM_RETURN_VAL_IF_FAIL(cb_base->object_stamp > 0, TDM_ERROR_INVALID_PARAMETER); caller_tid = syscall(SYS_gettid); assert(find_funcs[cb_base->type] != NULL); - /* When there is the previous waiting sync call, the other type sync call CAN't be handlered */ - if (waiting_tid > 0 && cb_base->sync == 1) - assert(waiting_cb_type == cb_base->type); + /* handling only output-status as sync */ + if (cb_base->type == TDM_THREAD_CB_OUTPUT_STATUS) { + TDM_RETURN_VAL_IF_FAIL(cb_base->sync == 1, TDM_ERROR_INVALID_PARAMETER); + } else { + TDM_RETURN_VAL_IF_FAIL(cb_base->sync == 0, TDM_ERROR_INVALID_PARAMETER); + } if (!object) { object = find_funcs[cb_base->type](private_display, cb_base->object_stamp); -- 2.7.4 From 352656cd6d668485334def211527f1c817a3317a Mon Sep 17 00:00:00 2001 From: Boram Park Date: Mon, 12 Mar 2018 17:42:25 +0900 Subject: [PATCH 07/16] package version up to 1.16.2 Change-Id: Id92045c2da6777f7efd18dfb7d05caca73b4d04e --- packaging/libtdm.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index 62b46e8..e90f82c 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -2,7 +2,7 @@ %define UTEST_GCOV 0 Name: libtdm -Version: 1.16.1 +Version: 1.16.2 Release: 0 Summary: User Library of Tizen Display Manager Group: Development/Libraries -- 2.7.4 From 1832b50e8e4186f8be0cd04c5f3c6bc7d2e260e4 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Tue, 13 Mar 2018 12:12:00 +0900 Subject: [PATCH 08/16] layer: add a missed callback Change-Id: Ia7b2b6a467a1ef7531e5f4be51f58f559c8ae97a --- src/tdm_layer.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tdm_layer.c b/src/tdm_layer.c index b36f37f..df7693a 100644 --- a/src/tdm_layer.c +++ b/src/tdm_layer.c @@ -946,7 +946,7 @@ _tdm_layer_commit(tdm_layer *layer, tdm_layer_commit_handler func, void *user_da if (_tdm_layer_commit_possible(private_layer)) { /* add to layer_commit_handler_list */ LIST_ADDTAIL(&layer_commit_handler->link, &private_output->layer_commit_handler_list); - ret = tdm_output_commit_internal(private_layer->private_output, 0, NULL, NULL); + ret = tdm_output_commit_internal(private_layer->private_output, 0, _tdm_layer_cb_output_commit, layer_commit_handler); TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed); if (tdm_debug_module & TDM_DEBUG_COMMIT) -- 2.7.4 From a87e1609d7c2be6fafbfba39fd930adcc0d23491 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Tue, 13 Mar 2018 12:12:24 +0900 Subject: [PATCH 09/16] output: add thread_cb even if func is null Change-Id: I64eb5588a02ef5d351e9e7debaf7faf00b40f558 --- src/tdm_output.c | 52 +++++++++++++++++++++++++--------------------------- 1 file changed, 25 insertions(+), 27 deletions(-) diff --git a/src/tdm_output.c b/src/tdm_output.c index e6eed12..652e262 100644 --- a/src/tdm_output.c +++ b/src/tdm_output.c @@ -1129,35 +1129,33 @@ tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handl TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, ret); if (!TDM_OUTPUT_DPMS_VSYNC_IS_OFF(dpms_value)) { - if (func) { - if (!private_output->regist_commit_cb) { - private_output->regist_commit_cb = 1; - ret = func_output->output_set_commit_handler(private_output->output_backend, _tdm_output_cb_commit); - TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed); - } - - 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 */ - } - - ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_COMMIT, output_commit_handler, _tdm_output_thread_cb_commit, NULL); - if (ret != TDM_ERROR_NONE) { - TDM_ERR("tdm_thread_cb_add failed"); - free(output_commit_handler); - return ret; - } - - LIST_ADDTAIL(&output_commit_handler->link, &private_output->output_commit_handler_list); - output_commit_handler->private_output = private_output; - output_commit_handler->func = func; - output_commit_handler->user_data = user_data; - output_commit_handler->owner_tid = syscall(SYS_gettid); + if (!private_output->regist_commit_cb) { + private_output->regist_commit_cb = 1; + ret = func_output->output_set_commit_handler(private_output->output_backend, _tdm_output_cb_commit); + TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed); } + 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 */ + } + + ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_COMMIT, output_commit_handler, _tdm_output_thread_cb_commit, NULL); + if (ret != TDM_ERROR_NONE) { + TDM_ERR("tdm_thread_cb_add failed"); + free(output_commit_handler); + return ret; + } + + LIST_ADDTAIL(&output_commit_handler->link, &private_output->output_commit_handler_list); + output_commit_handler->private_output = private_output; + output_commit_handler->func = func; + output_commit_handler->user_data = user_data; + output_commit_handler->owner_tid = syscall(SYS_gettid); + ret = func_output->output_commit(private_output->output_backend, sync, output_commit_handler); TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed); -- 2.7.4 From 2007dd789c9a3779cee43931fe16e167c8e9bfe3 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Tue, 13 Mar 2018 13:17:23 +0900 Subject: [PATCH 10/16] client: lock / unlock in tdm_client_handle_events_timeout Change-Id: I6749fef9293951b5e188634756e74d2e56f5c81f --- client/tdm_client.c | 34 ++++++++++++++++++++++++++++++---- 1 file changed, 30 insertions(+), 4 deletions(-) diff --git a/client/tdm_client.c b/client/tdm_client.c index 84b4c07..81998e6 100644 --- a/client/tdm_client.c +++ b/client/tdm_client.c @@ -592,8 +592,12 @@ _tdm_client_dispatch_timeout(tdm_private_client *private_client, int timeout) int ret; struct wl_display *display = private_client->display; - if (wl_display_prepare_read(display) == -1) - return wl_display_dispatch_pending(display); + if (wl_display_prepare_read(display) == -1) { + if (wl_display_dispatch_pending(display) > 0) + return TDM_ERROR_NONE; + else + return TDM_ERROR_OPERATION_FAILED; + } while (true) { ret = wl_display_flush(display); @@ -647,12 +651,34 @@ tdm_error tdm_client_handle_events_timeout(tdm_client *client, int ms_timeout) { tdm_private_client *private_client; - + tdm_error ret; TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER); private_client = (tdm_private_client*)client; - return _tdm_client_dispatch_timeout(private_client, ms_timeout); + pthread_mutex_lock(&private_client->lock); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + if (private_client->enable_ttrace) + TDM_TRACE_ASYNC_BEGIN((int)private_client->stamp, "TDM_Client_Events_Timeout:%u", (unsigned int)private_client->stamp); + + ret = _tdm_client_dispatch_timeout(private_client, ms_timeout); + + if (private_client->enable_ttrace) + TDM_TRACE_ASYNC_END((int)private_client->stamp, "TDM_Client_Events_Timeout:%u", (unsigned int)private_client->stamp); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + pthread_mutex_unlock(&private_client->lock); + + return ret; } typedef struct _tdm_client_vblank_temp { -- 2.7.4 From 34a31225fd5db98eb0dee09684558e2910be4537 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Tue, 13 Mar 2018 13:18:04 +0900 Subject: [PATCH 11/16] event_loop: deinit event_loop after stopping Change-Id: Id3c6e588fa19fedf849f766df594521e17ba201c --- src/tdm.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/tdm.c b/src/tdm.c index 7d80016..5146f7e 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -1140,9 +1140,10 @@ tdm_display_deinit(tdm_display *dpy) */ _pthread_mutex_lock(&private_display->lock); tdm_event_loop_stop(private_display); - tdm_event_loop_deinit(private_display); _pthread_mutex_unlock(&private_display->lock); + tdm_event_loop_deinit(private_display); + /* when private_output is destroyed, all vblank resources of client and server * are destroyed. Then we can call tdm_vblank_deinit. After destroying display, * we can unload backend modulues. -- 2.7.4 From 9afdee2052f184e611b5353bd52600805e152783 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Tue, 13 Mar 2018 13:56:32 +0900 Subject: [PATCH 12/16] macro: add some macros for debug Change-Id: I0f9c9738ff849d13877b0b383da5578848f4f860 --- src/tdm.c | 4 ++++ src/tdm_macro.h | 23 +++++++++++++++++++++++ 2 files changed, 27 insertions(+) diff --git a/src/tdm.c b/src/tdm.c index 5146f7e..effa0f3 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -46,6 +46,10 @@ int tdm_mutex_lock_line; const char *tdm_mutex_unlock_func; int tdm_mutex_unlock_line; +pthread_mutex_t tdm_debug_mutex_check_lock = PTHREAD_MUTEX_INITIALIZER; +const char *tdm_debug_mutex_lock_func; +int tdm_debug_mutex_lock_line; + /* LCOV_EXCL_START */ static tdm_private_layer * _tdm_display_find_private_layer(tdm_private_output *private_output, diff --git a/src/tdm_macro.h b/src/tdm_macro.h index 80be131..acdc9f3 100644 --- a/src/tdm_macro.h +++ b/src/tdm_macro.h @@ -461,6 +461,29 @@ static inline int TDM_MUTEX_IS_LOCKED(void) #define tdm_display_unlock(dpy) _pthread_mutex_unlock(&((tdm_private_display *)dpy)->lock) +/* debugging mutex ************************************************************/ +extern pthread_mutex_t tdm_debug_mutex_check_lock; +extern const char *tdm_debug_mutex_lock_func; +extern int tdm_debug_mutex_lock_line; + +#define _debug_pthread_mutex_lock(l) \ + do { \ + pthread_mutex_lock(l); \ + pthread_mutex_lock(&tdm_debug_mutex_check_lock); \ + tdm_debug_mutex_lock_func = __FUNCTION__; \ + tdm_debug_mutex_lock_line = __LINE__; \ + pthread_mutex_unlock(&tdm_debug_mutex_check_lock); \ + } while (0) + +#define _debug_pthread_mutex_unlock(l) \ + do { \ + pthread_mutex_lock(&tdm_debug_mutex_check_lock); \ + tdm_debug_mutex_lock_func = NULL; \ + tdm_debug_mutex_lock_line = 0; \ + pthread_mutex_unlock(&tdm_debug_mutex_check_lock); \ + pthread_mutex_unlock(l); \ + } while (0) + #ifdef __cplusplus } #endif -- 2.7.4 From 7e1fe7b623936e90af2883cafc1216df5bdc468d Mon Sep 17 00:00:00 2001 From: Boram Park Date: Tue, 13 Mar 2018 08:23:29 +0900 Subject: [PATCH 13/16] tdm: init fd Change-Id: I8585cd3874f01ebe8d146abd5a8ede64d52da573 --- src/tdm.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/tdm.c b/src/tdm.c index effa0f3..42387fd 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -435,6 +435,8 @@ tdm_display_update_output(tdm_private_module *private_module, LIST_INITHEAD(&private_output->pending_commit_handler_list); LIST_INITHEAD(&private_output->change_handler_list); + private_output->need_validate.event_fd = -1; + if (func_output->output_set_status_handler) { func_output->output_set_status_handler(private_output->output_backend, tdm_output_cb_status, -- 2.7.4 From 2cc0367ef920dc8dcd26222c0f851d1c3835db9d Mon Sep 17 00:00:00 2001 From: Boram Park Date: Tue, 13 Mar 2018 08:23:18 +0900 Subject: [PATCH 14/16] utest: correct wrong behaviors Change-Id: I57b023a9800a0b4fba993397365c183ba81ba647 --- utests/Makefile.am | 8 +- utests/src/ut_tdm.h | 193 ++- ..._tdm_capture.cpp => ut_tdm_backend_capture.cpp} | 124 +- utests/src/ut_tdm_backend_display.cpp | 1398 ++++++++++++++++++++ utests/src/ut_tdm_backend_env.cpp | 79 ++ .../src/{ut_tdm_pp.cpp => ut_tdm_backend_pp.cpp} | 256 ++-- utests/src/ut_tdm_buffer.cpp | 11 +- utests/src/ut_tdm_client.cpp | 195 +-- utests/src/ut_tdm_display.cpp | 59 +- utests/src/ut_tdm_env.cpp | 32 +- utests/src/ut_tdm_event_loop.cpp | 14 +- utests/src/ut_tdm_helper.cpp | 12 +- utests/src/ut_tdm_hwc_window.cpp | 9 +- utests/src/ut_tdm_layer.cpp | 438 +++--- utests/src/ut_tdm_log.cpp | 3 - utests/src/ut_tdm_output.cpp | 338 ++--- utests/src/ut_tdm_output_hwc.cpp | 7 +- utests/src/ut_tdm_vblank.cpp | 64 +- 18 files changed, 2510 insertions(+), 730 deletions(-) rename utests/src/{ut_tdm_capture.cpp => ut_tdm_backend_capture.cpp} (86%) create mode 100644 utests/src/ut_tdm_backend_display.cpp create mode 100644 utests/src/ut_tdm_backend_env.cpp rename utests/src/{ut_tdm_pp.cpp => ut_tdm_backend_pp.cpp} (64%) diff --git a/utests/Makefile.am b/utests/Makefile.am index e4624ca..7c22473 100644 --- a/utests/Makefile.am +++ b/utests/Makefile.am @@ -13,9 +13,11 @@ tdm_utests_SOURCES = \ src/ut_tdm_layer.cpp \ src/ut_tdm_output_hwc.cpp \ src/ut_tdm_hwc_window.cpp \ - src/ut_tdm_pp.cpp \ - src/ut_tdm_capture.cpp \ - src/ut_tdm_client.cpp + src/ut_tdm_client.cpp \ + src/ut_tdm_backend_env.cpp \ + src/ut_tdm_backend_display.cpp \ + src/ut_tdm_backend_pp.cpp \ + src/ut_tdm_backend_capture.cpp tdm_utests_SOURCES += \ ../tools/buffers.c diff --git a/utests/src/ut_tdm.h b/utests/src/ut_tdm.h index c29a2b1..83f1bcb 100644 --- a/utests/src/ut_tdm.h +++ b/utests/src/ut_tdm.h @@ -9,6 +9,9 @@ #include #include #include +#include +#include +#include extern "C" { #include @@ -22,73 +25,107 @@ extern "C" { #include "tdm_macro.h" #include "buffers.h" -#define UT_TDM_BUFFER_ENABLE -#define UT_TDM_CAPTURE_ENABLE -#define UT_TDM_CLIENT_ENABLE -#define UT_TDM_DISPLAY_ENABLE -#define UT_TDM_ENV_ENABLE -#define UT_TDM_EVENT_LOOP_ENABLE -#define UT_TDM_HELPER_ENABLE -#define UT_TDM_OUTPUT_HWC_ENABLE -#define UT_TDM_HWC_WINDOW_ENABLE -#define UT_TDM_LAYER_ENABLE -#define UT_TDM_LOG_ENABLE -#define UT_TDM_OUTPUT_ENABLE -#define UT_TDM_PP_ENABLE -#define UT_TDM_VBLANK_ENABLE +//#define TDM_UT_TEST_WITH_PARAMS + +extern bool enable_porting_debug; #undef TDM_DBG -#define TDM_DBG(fmt, args...) \ - tdm_log_print(TDM_LOG_LEVEL_DBG, fmt, ##args); #undef TDM_INFO -#define TDM_INFO(fmt, args...) \ - tdm_log_print(TDM_LOG_LEVEL_INFO, fmt, ##args); #undef TDM_WRN -#define TDM_WRN(fmt, args...) \ - tdm_log_print(TDM_LOG_LEVEL_WRN, fmt, ##args); #undef TDM_ERR -#define TDM_ERR(fmt, args...) \ - tdm_log_print(TDM_LOG_LEVEL_ERR, fmt, ##args); +#define TDM_DBG(fmt, args...) tdm_log_print(TDM_LOG_LEVEL_DBG, fmt, ##args) +#define TDM_INFO(fmt, args...) tdm_log_print(TDM_LOG_LEVEL_INFO, fmt, ##args) +#define TDM_WRN(fmt, args...) tdm_log_print(TDM_LOG_LEVEL_WRN, fmt, ##args) +#define TDM_ERR(fmt, args...) tdm_log_print(TDM_LOG_LEVEL_ERR, fmt, ##args) + +#define TDM_UT_INFO(fmt, args...) tdm_log_print_stdout(TDM_LOG_LEVEL_INFO, fmt, ##args) +#define TDM_UT_ERR(fmt, args...) tdm_log_print_stdout(TDM_LOG_LEVEL_ERR, fmt, ##args) #define TDM_UT_ENTRY() \ - TDM_INFO("--------------------------------------------- %s", typeid(*this).name()) + TDM_ERR("--------------------------------------------- %s", typeid(*this).name()) #define TDM_UT_CHECK_FLAG(FLAG) \ do {\ if(!(FLAG)) \ - TDM_INFO("[ ] not supported");\ + TDM_UT_INFO("[ ] not supported");\ } while(0) #define TDM_UT_SKIP_FLAG(FLAG) \ do {\ if(!(FLAG)) {\ - TDM_INFO("[ SKIPPED ] not supported");\ + TDM_UT_INFO("[ SKIPPED ] not supported");\ return;\ }\ } while(0) -#define TDM_UT_NEVER_GET_HERE() \ - do {\ - TDM_INFO("!!! TDM UT NEVER GET HERE !!!");\ +#define TDM_UT_RETURN_IF_FAIL(cond) \ + do { \ + if (!(cond)) { \ + TDM_UT_ERR("[%s,%d] '%s' failed", __FUNCTION__, __LINE__, #cond); \ + return; \ + } \ + } while(0) +#define TDM_UT_RETURN_FALSE_IF_FAIL(cond) \ + do { \ + if (!(cond)) { \ + TDM_UT_ERR("[%s,%d] '%s' failed", __FUNCTION__, __LINE__, #cond); \ + return false; \ + } \ + } while(0) +#define TDM_UT_RETURN_VAL_IF_FAIL(cond, val) \ + do { \ + if (!(cond)) { \ + TDM_UT_ERR("[%s,%d] '%s' failed", __FUNCTION__, __LINE__, #cond); \ + return val; \ + } \ + } while(0) +#define TDM_UT_GOTO_IF_FAIL(cond, dst) \ + do { \ + if (!(cond)) { \ + TDM_UT_ERR("[%s,%d] '%s' failed", __FUNCTION__, __LINE__, #cond); \ + goto dst; \ + } \ + } while(0) + +#define TDM_UT_ASSERT_TRUE(cond, fmt, args...) \ + do { \ + if (!(cond)) { \ + if (enable_porting_debug) \ + TDM_UT_ERR(fmt, ##args); \ + GTEST_TEST_BOOLEAN_((cond), #cond, false, true, GTEST_FATAL_FAILURE_); \ + } \ + } while(0) +#define TDM_UT_EXPECT_TRUE(cond, fmt, args...) \ + do { \ + if (!(cond)) { \ + if (enable_porting_debug) \ + TDM_UT_ERR(fmt, ##args); \ + GTEST_TEST_BOOLEAN_((cond), #cond, false, true, GTEST_NONFATAL_FAILURE_); \ + } \ } while(0) -#define TDM_UT_RETURN_IF_FAIL(cond) { \ - if (!(cond)) { \ - TDM_ERR("[%s,%d] '%s' failed", __FUNCTION__, __LINE__, #cond); \ - return; \ - } \ -} -#define TDM_UT_RETURN_FALSE_IF_FAIL(cond) { \ - if (!(cond)) { \ - TDM_ERR("[%s,%d] '%s' failed", __FUNCTION__, __LINE__, #cond); \ - return false; \ - } \ -} -#define TDM_UT_GOTO_IF_FAIL(cond, dst) { \ - if (!(cond)) { \ - TDM_ERR("[%s,%d] '%s' failed", __FUNCTION__, __LINE__, #cond); \ - goto dst; \ - } \ -} + +#define TDM_UT_ASK_YNR(fmt, ...) \ + do { \ + if (enable_porting_debug) { \ + char ch; \ + printf(fmt" [Y]es, [n]o, [r]etry: ", ##__VA_ARGS__); \ + do { \ + ch = getchar(); \ + if (ch == '\n') \ + ch = 'y'; \ + else { \ + char tch; \ + while ((tch = getchar()) != '\n' && tch != EOF); \ + } \ + } while (ch != 'y' && ch != 'Y' && ch != 'n' && ch != 'N' && ch != 'r' && ch != 'R'); \ + if (ch == 'n' || ch == 'N') \ + GTEST_FATAL_FAILURE_("tc failed"); \ + if (ch == 'r' || ch == 'R') \ + goto retry; \ + } else { \ + usleep(1000000); /* 1000 ms */ \ + } \ + } while (0) #define TDM_UT_SIZE_ALIGN(value, base) (((value) + ((base) - 1)) & ~((base) - 1)) @@ -102,12 +139,21 @@ using ::testing::Bool; using ::testing::Values; using ::testing::Combine; +#ifdef TDM_UT_TEST_WITH_PARAMS class TDMEnv : public TestWithParam< ::testing::tuple > { public: void SetUp(void); void TearDown(void); }; +#else +class TDMEnv : public TestWithParam< ::testing::tuple > +{ +public: + void SetUp(void); + void TearDown(void); +}; +#endif class TDMDisplay : public TDMEnv { @@ -129,6 +175,9 @@ public: bool has_outputs; tdm_output **outputs; int output_count; + + bool done1, done2, done3; + TDMOutput(); void SetUp(void); void TearDown(void); @@ -138,30 +187,76 @@ public: extern "C" void __gcov_flush(void); #endif +tdm_error ut_tdm_display_handle_events(tdm_display *dpy); +bool ut_tdm_display_has_pp_capability(tdm_display *dpy); +bool ut_tdm_display_has_capture_capability(tdm_display *dpy); + bool ut_tdm_buffer_create(int width, int height, tbm_format format, int flags, bool fill, int count, tbm_surface_h *buffers); -bool ut_tdm_output_mode_setting(tdm_output *output); bool ut_tdm_output_is_async_dpms_enable(tdm_output *output); bool ut_tdm_output_is_hwc_enable(tdm_output *output); bool ut_tdm_output_is_aod_enable(tdm_output *output); bool ut_tdm_output_is_connected(tdm_output *output); -bool ut_tdm_output_prepare(tdm_display *dpy, tdm_output *output); +bool ut_tdm_output_mode_setting(tdm_output *output); +bool ut_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill); +bool ut_tdm_output_prepare_all_output(tdm_display *dpy, tdm_output **outputs, int output_count, bool fill); bool ut_tdm_output_unset(tdm_display *dpy, tdm_output *output); double ut_tdm_output_get_vblank_interval_time(tdm_output *output); +tdm_layer *ut_tdm_output_get_primary_layer(tdm_output *output); bool ut_tdm_layer_is_cursor_layer(tdm_layer *layer); bool ut_tdm_layer_is_primary_layer(tdm_layer *layer); bool ut_tdm_layer_is_video_layer(tdm_layer *layer); -bool ut_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer_count); +bool ut_tdm_layer_support_scale(tdm_layer *layer); +bool ut_tdm_layer_support_no_crop(tdm_layer *layer); +bool ut_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer_count, bool fill); bool ut_tdm_layer_prepare_buffer_queue(tdm_layer *layer, tbm_surface_queue_h *buffer_queue); bool ut_tdm_layer_fill_info(tdm_layer *layer, int w, int h, tbm_format format, tdm_info_layer *info); +bool ut_tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer); unsigned int ut_tdm_layer_get_output_pipe(tdm_layer *layer); tbm_format ut_tdm_layer_find_best_format(tdm_layer *layer); +bool ut_tdm_layer_is_avaiable(tdm_layer *layer); bool ut_tdm_pp_fill_info(tbm_surface_h srcbuf, tbm_surface_h dstbuf, tdm_transform transform, tdm_info_pp *info); bool ut_tdm_capture_fill_info(tdm_output *output, tbm_surface_h buffer, tdm_transform transform, tdm_capture_type type, int frequency, tdm_info_capture *info); +/******************************************************************************/ +/** testing for checking backend's basic implementation **/ +/******************************************************************************/ +class TDMBackendEnv : public TDMEnv +{ +public: + void SetUp(void); + void TearDown(void); +}; + +class TDMBackendBasic : public TDMBackendEnv +{ +public: + tdm_display *dpy; + + tdm_output **outputs; + int output_count; + + tdm_layer **layers; + int layer_count; + + tbm_surface_h buffers[3]; + + TDMBackendBasic(); + void SetUp(void); + void TearDown(void); + void UnsetOutput(void); + void DestroyBuffers(void); +}; + +class TDMBackendDisplay : public TDMBackendBasic +{ +public: + void SetUp(void) { TDMBackendBasic::SetUp(); } + void TearDown(void) { TDMBackendBasic::TearDown(); } +}; #endif // _UT_TDM_H_ diff --git a/utests/src/ut_tdm_capture.cpp b/utests/src/ut_tdm_backend_capture.cpp similarity index 86% rename from utests/src/ut_tdm_capture.cpp rename to utests/src/ut_tdm_backend_capture.cpp index 25c48f8..ecbe06b 100644 --- a/utests/src/ut_tdm_capture.cpp +++ b/utests/src/ut_tdm_backend_capture.cpp @@ -30,8 +30,11 @@ #include "ut_tdm.h" -class TDMCapture : public TDMOutput { +class TDMBackendCapture : public TDMBackendDisplay +{ public: + bool has_capture_cap; + tdm_capture *capture; tdm_capture_capability capabilities; const tbm_format *formats; @@ -48,7 +51,7 @@ public: tdm_output *output; - TDMCapture(); + TDMBackendCapture(); void SetUp(void); void TearDown(void); @@ -60,8 +63,9 @@ public: void DestroyBuffers(void); }; -TDMCapture::TDMCapture() +TDMBackendCapture::TDMBackendCapture() { + has_capture_cap = false; capture = NULL; capabilities = (tdm_capture_capability)0; formats = NULL; @@ -74,46 +78,47 @@ TDMCapture::TDMCapture() output = NULL; } -void TDMCapture::SetUp(void) +void TDMBackendCapture::SetUp(void) { - TDMOutput::SetUp(); + tdm_display_capability dpy_capabilities; - tdm_error ret; - tdm_output *output; + TDMBackendDisplay::SetUp(); + + ASSERT_TRUE(tdm_display_get_capabilities(dpy, &dpy_capabilities) == TDM_ERROR_NONE); + has_capture_cap = dpy_capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE; if (!has_capture_cap) return; for (int o = 0; o < output_count; o++) { - output = tdm_display_get_output(dpy, o, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); - - if (!ut_tdm_output_is_connected(output)) + if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, output) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); } } -void TDMCapture::TearDown(void) +void TDMBackendCapture::TearDown(void) { if (capture) tdm_capture_destroy(capture); + for (int o = 0; o < output_count; o++) { + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(ut_tdm_output_unset(dpy, outputs[o]) == true); + } + DestroyBuffers(); - TDMOutput::TearDown(); + TDMBackendDisplay::TearDown(); } -bool TDMCapture::TestPrepareDefault(void) +bool TDMBackendCapture::TestPrepareDefault(void) { tdm_error ret; - TDM_UT_RETURN_FALSE_IF_FAIL(has_outputs == true); - TDM_UT_RETURN_FALSE_IF_FAIL(outputs != NULL); - TDM_UT_RETURN_FALSE_IF_FAIL(output_count > 0); - TDM_UT_RETURN_FALSE_IF_FAIL(tdm_display_get_capture_capabilities(dpy, &capabilities) == TDM_ERROR_NONE); TDM_UT_RETURN_FALSE_IF_FAIL(capabilities > 0); TDM_UT_RETURN_FALSE_IF_FAIL(tdm_display_get_capture_available_formats(dpy, &formats, &format_count) == TDM_ERROR_NONE); @@ -147,7 +152,7 @@ bool TDMCapture::TestPrepareDefault(void) return (capture) ? true : false; } -bool TDMCapture::FindFormat(tbm_format fmt) +bool TDMBackendCapture::FindFormat(tbm_format fmt) { bool found = false; @@ -167,11 +172,10 @@ bool TDMCapture::FindFormat(tbm_format fmt) return found; } -bool TDMCapture::TestPrepare(int output_idx, int w, int h, tbm_format fmt, tdm_transform t, tdm_capture_type c, int frequency) +bool TDMBackendCapture::TestPrepare(int output_idx, int w, int h, tbm_format fmt, tdm_transform t, tdm_capture_type c, int frequency) { tdm_error ret; - TDM_UT_RETURN_FALSE_IF_FAIL(has_outputs == true); TDM_UT_RETURN_FALSE_IF_FAIL(outputs != NULL); TDM_UT_RETURN_FALSE_IF_FAIL(output_count > 0); TDM_UT_RETURN_FALSE_IF_FAIL(output_count >= output_idx); @@ -201,7 +205,7 @@ bool TDMCapture::TestPrepare(int output_idx, int w, int h, tbm_format fmt, tdm_t return true; } -void TDMCapture::TestDone(void) +void TDMBackendCapture::TestDone(void) { if (capture) { tdm_capture_destroy(capture); @@ -211,7 +215,7 @@ void TDMCapture::TestDone(void) DestroyBuffers(); } -void TDMCapture::DumpBuffers(int b, char *test) +void TDMBackendCapture::DumpBuffers(int b, char *test) { char filename[256]; if (test) @@ -221,7 +225,7 @@ void TDMCapture::DumpBuffers(int b, char *test) tdm_helper_dump_buffer_str(buffers[b], NULL, filename); } -void TDMCapture::DestroyBuffers(void) +void TDMBackendCapture::DestroyBuffers(void) { for (int b = 0; b < 3; b++) { tbm_surface_destroy(buffers[b]); @@ -273,8 +277,6 @@ ut_tdm_capture_fill_info(tdm_output *output, tbm_surface_h buffer, tdm_transform return true; } -#ifdef UT_TDM_CAPTURE_ENABLE - static tbm_format test_formats[] = { TBM_FORMAT_ARGB8888, TBM_FORMAT_XRGB8888, @@ -286,7 +288,7 @@ static tbm_format test_formats[] = { #define TEST_FORMAT_CNT (int)(sizeof(test_formats) / sizeof((test_formats)[0])) -TEST_P(TDMCapture, CaptureDispalyGetAvaiableFormats) +TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableFormats) { const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; @@ -301,7 +303,7 @@ TEST_P(TDMCapture, CaptureDispalyGetAvaiableFormats) } } -TEST_P(TDMCapture, CaptureDispalyGetAvaiableFormatsNullObject) +TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableFormatsNullObject) { const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; @@ -310,12 +312,12 @@ TEST_P(TDMCapture, CaptureDispalyGetAvaiableFormatsNullObject) ASSERT_TRUE(count == TDM_UT_INVALID_VALUE); } -TEST_P(TDMCapture, CaptureDispalyGetAvaiableFormatsNullOther) +TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableFormatsNullOther) { ASSERT_TRUE(tdm_display_get_capture_available_formats(dpy, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); } -TEST_P(TDMCapture, CaptureDispalyGetAvaiableSize) +TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableSize) { int min_w = TDM_UT_INVALID_VALUE; int min_h = TDM_UT_INVALID_VALUE; @@ -339,7 +341,7 @@ TEST_P(TDMCapture, CaptureDispalyGetAvaiableSize) } } -TEST_P(TDMCapture, CaptureDispalyGetAvaiableSizeNullObject) +TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableSizeNullObject) { int min_w = TDM_UT_INVALID_VALUE; int min_h = TDM_UT_INVALID_VALUE; @@ -354,7 +356,7 @@ TEST_P(TDMCapture, CaptureDispalyGetAvaiableSizeNullObject) ASSERT_TRUE(preferred_align == TDM_UT_INVALID_VALUE); } -TEST_P(TDMCapture, CaptureDispalyGetAvaiableSizeNullOther) +TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableSizeNullOther) { if (has_capture_cap) ASSERT_TRUE(tdm_display_get_capture_available_size(dpy, NULL, NULL, NULL, NULL, NULL) == TDM_ERROR_NONE); @@ -362,7 +364,7 @@ TEST_P(TDMCapture, CaptureDispalyGetAvaiableSizeNullOther) ASSERT_TRUE(tdm_display_get_capture_available_size(dpy, NULL, NULL, NULL, NULL, NULL) == TDM_ERROR_NO_CAPABILITY); } -TEST_P(TDMCapture, CaptureDestroy) +TEST_P(TDMBackendCapture, CaptureDestroy) { TDM_UT_SKIP_FLAG(has_capture_cap); @@ -371,19 +373,19 @@ TEST_P(TDMCapture, CaptureDestroy) TestDone(); } -TEST_P(TDMCapture, CaptureDestroyNullObject) +TEST_P(TDMBackendCapture, CaptureDestroyNullObject) { TDM_UT_SKIP_FLAG(has_capture_cap); tdm_capture_destroy(NULL); } -TEST_P(TDMCapture, CaptureSetInfo) +TEST_P(TDMBackendCapture, CaptureSetInfo) { /* tested in CaptureNoScaleNoTransformNoCSC */ } -TEST_P(TDMCapture, CaptureSetInfoNullObject) +TEST_P(TDMBackendCapture, CaptureSetInfoNullObject) { TDM_UT_SKIP_FLAG(has_capture_cap); @@ -392,7 +394,7 @@ TEST_P(TDMCapture, CaptureSetInfoNullObject) ASSERT_TRUE(tdm_capture_set_info(NULL, &info) == TDM_ERROR_INVALID_PARAMETER); } -TEST_P(TDMCapture, CaptureSetInfoNullOther) +TEST_P(TDMBackendCapture, CaptureSetInfoNullOther) { TDM_UT_SKIP_FLAG(has_capture_cap); @@ -411,7 +413,7 @@ _ut_tdm_capture_done_cb(tdm_capture *capture, tbm_surface_h buffer, void *user_d *done = true; } -TEST_P(TDMCapture, CaptureSetDoneHandler) +TEST_P(TDMBackendCapture, CaptureSetDoneHandler) { TDM_UT_SKIP_FLAG(has_capture_cap); @@ -422,14 +424,14 @@ TEST_P(TDMCapture, CaptureSetDoneHandler) TestDone(); } -TEST_P(TDMCapture, CaptureSetDoneHandlerNullObject) +TEST_P(TDMBackendCapture, CaptureSetDoneHandlerNullObject) { TDM_UT_SKIP_FLAG(has_capture_cap); ASSERT_TRUE(tdm_capture_set_done_handler(NULL, _ut_tdm_capture_done_cb, NULL) == TDM_ERROR_INVALID_PARAMETER); } -TEST_P(TDMCapture, CaptureSetDoneHandlerNullOther) +TEST_P(TDMBackendCapture, CaptureSetDoneHandlerNullOther) { TDM_UT_SKIP_FLAG(has_capture_cap); @@ -440,7 +442,7 @@ TEST_P(TDMCapture, CaptureSetDoneHandlerNullOther) TestDone(); } -TEST_P(TDMCapture, CaptureAttach) +TEST_P(TDMBackendCapture, CaptureAttach) { TDM_UT_SKIP_FLAG(has_capture_cap); @@ -464,7 +466,7 @@ TEST_P(TDMCapture, CaptureAttach) } } -TEST_P(TDMCapture, CaptureAttachNullObject) +TEST_P(TDMBackendCapture, CaptureAttachNullObject) { TDM_UT_SKIP_FLAG(has_capture_cap); @@ -473,7 +475,7 @@ TEST_P(TDMCapture, CaptureAttachNullObject) ASSERT_TRUE(tdm_capture_attach(NULL, buffer) == TDM_ERROR_INVALID_PARAMETER); } -TEST_P(TDMCapture, CaptureAttachNullOther) +TEST_P(TDMBackendCapture, CaptureAttachNullOther) { TDM_UT_SKIP_FLAG(has_capture_cap); @@ -484,7 +486,7 @@ TEST_P(TDMCapture, CaptureAttachNullOther) TestDone(); } -TEST_P(TDMCapture, CaptureCommit) +TEST_P(TDMBackendCapture, CaptureCommit) { TDM_UT_SKIP_FLAG(has_capture_cap); @@ -495,14 +497,14 @@ TEST_P(TDMCapture, CaptureCommit) TestDone(); } -TEST_P(TDMCapture, CaptureCommitNullOBject) +TEST_P(TDMBackendCapture, CaptureCommitNullOBject) { TDM_UT_SKIP_FLAG(has_capture_cap); ASSERT_TRUE(tdm_capture_commit(NULL) == TDM_ERROR_INVALID_PARAMETER); } -TEST_P(TDMCapture, CaptureCommitDpmsOff) +TEST_P(TDMBackendCapture, CaptureCommitDpmsOff) { TDM_UT_SKIP_FLAG(has_capture_cap); @@ -517,7 +519,7 @@ TEST_P(TDMCapture, CaptureCommitDpmsOff) TestDone(); } -TEST_P(TDMCapture, CaptureNoScaleNoTransformNoCSC) +TEST_P(TDMBackendCapture, CaptureNoScaleNoTransformNoCSC) { TDM_UT_SKIP_FLAG(has_capture_cap); @@ -549,7 +551,7 @@ TEST_P(TDMCapture, CaptureNoScaleNoTransformNoCSC) ASSERT_TRUE(tdm_capture_commit(capture) == TDM_ERROR_NONE); while (!done) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); DumpBuffers(b, temp); } @@ -559,7 +561,7 @@ TEST_P(TDMCapture, CaptureNoScaleNoTransformNoCSC) } } -TEST_P(TDMCapture, CaptureScaleTransformCSC) +TEST_P(TDMBackendCapture, CaptureScaleTransformCSC) { TDM_UT_SKIP_FLAG(has_capture_cap); @@ -591,7 +593,7 @@ TEST_P(TDMCapture, CaptureScaleTransformCSC) ASSERT_TRUE(tdm_capture_commit(capture) == TDM_ERROR_NONE); while (!done) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); DumpBuffers(b, temp); } @@ -609,7 +611,7 @@ _ut_tdm_capture_done_cb2(tdm_capture *capture, tbm_surface_h buffer, void *user_ (*done)++; } -TEST_P(TDMCapture, CaptureAttachFewTimesInOneCommit) +TEST_P(TDMBackendCapture, CaptureAttachFewTimesInOneCommit) { TDM_UT_SKIP_FLAG(has_capture_cap); @@ -641,7 +643,7 @@ TEST_P(TDMCapture, CaptureAttachFewTimesInOneCommit) ASSERT_TRUE(tdm_capture_commit(capture) == TDM_ERROR_NONE); while (done != 3) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); for (int b = 0; b < 3; b++) DumpBuffers(b, temp); @@ -650,7 +652,7 @@ TEST_P(TDMCapture, CaptureAttachFewTimesInOneCommit) } } -TEST_P(TDMCapture, CaptureDestroyWithoutCommit) +TEST_P(TDMBackendCapture, CaptureDestroyWithoutCommit) { TDM_UT_SKIP_FLAG(has_capture_cap); @@ -681,7 +683,7 @@ TEST_P(TDMCapture, CaptureDestroyWithoutCommit) } } -TEST_P(TDMCapture, CaptureDestroyBeforeDone) +TEST_P(TDMBackendCapture, CaptureDestroyBeforeDone) { TDM_UT_SKIP_FLAG(has_capture_cap); @@ -714,8 +716,12 @@ TEST_P(TDMCapture, CaptureDestroyBeforeDone) } } -INSTANTIATE_TEST_CASE_P(TDMCaptureParams, - TDMCapture, +#ifdef TDM_UT_TEST_WITH_PARAMS +INSTANTIATE_TEST_CASE_P(TDMBackendCaptureParams, + TDMBackendCapture, Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE))); - +#else +INSTANTIATE_TEST_CASE_P(TDMBackendCaptureParams, + TDMBackendCapture, + Values(TDM_DEFAULT_MODULE)); #endif diff --git a/utests/src/ut_tdm_backend_display.cpp b/utests/src/ut_tdm_backend_display.cpp new file mode 100644 index 0000000..a01c804 --- /dev/null +++ b/utests/src/ut_tdm_backend_display.cpp @@ -0,0 +1,1398 @@ +/************************************************************************** + * + * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved. + * + * Contact: Konstantin Drabeniuk + * Contact: Andrii Sokolenko + * Contact: Roman Marchenko + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sub license, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial portions + * of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. + * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR + * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * +**************************************************************************/ + +#include "ut_tdm.h" + +#define TDM_UT_BACKEND_TEST_CNT 20 + +TDMBackendBasic::TDMBackendBasic() +{ + dpy = NULL; + outputs = NULL; + output_count = 0; + layers = NULL; + layer_count = 0; + + for (int b = 0; b < 3; b++) + buffers[b] = NULL; +} + +void TDMBackendBasic::SetUp(void) +{ + tdm_error ret; + + TDMBackendEnv::SetUp(); + + dpy = tdm_display_init(&ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_TRUE(dpy != NULL); + + ASSERT_TRUE(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE); + ASSERT_TRUE(output_count >= 0); + + if (output_count > 0) { + outputs = (tdm_output**)calloc(output_count, sizeof (tdm_output*)); + ASSERT_TRUE(outputs != NULL); + + for (int o = 0; o < output_count; o++) { + tdm_error ret; + tdm_output *output = tdm_display_get_output(dpy, o, &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_TRUE(output != NULL); + outputs[o] = output; + } + } + + for (int o = 0; o < output_count; o++) { + int old_layer_count = layer_count, count = TDM_UT_INVALID_VALUE; + tdm_error ret; + + if (ut_tdm_output_is_hwc_enable(outputs[o])) + continue; + + ASSERT_TRUE(tdm_output_get_layer_count(outputs[o], &count) == TDM_ERROR_NONE); + ASSERT_TRUE(count > 0); + + layer_count += count; + layers = (tdm_layer**)realloc((void*)layers, sizeof(tdm_layer*) * layer_count); + ASSERT_TRUE(layers != NULL); + + for (int l = 0; l < count; l++) { + tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret); + ASSERT_TRUE(layer != NULL); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + layers[old_layer_count + l] = layer; + } + } +} + +void TDMBackendBasic::TearDown(void) +{ + tdm_display_deinit(dpy); + dpy = NULL; + + free(outputs); + outputs = NULL; + output_count = 0; + + free(layers); + layers = NULL; + layer_count = 0; + + DestroyBuffers(); + + ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0); + + TDMBackendEnv::TearDown(); +} + +void TDMBackendBasic::DestroyBuffers(void) +{ + for (int b = 0; b < 3; b++) { + if (buffers[b]) + tbm_surface_destroy(buffers[b]); + buffers[b] = NULL; + } +} + +TEST_P(TDMBackendBasic, VerifyOutputObject) +{ + tdm_error ret; + int output_count = 0; + + ASSERT_TRUE(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE); + TDM_UT_ASSERT_TRUE(output_count > 0, "output count(%d) should be greater than 0. Check display_get_outputs()."); + + for (int o = 0; o < output_count; o++) { + tdm_output *output = tdm_display_get_output(dpy, o, &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + TDM_UT_ASSERT_TRUE(output != NULL, "no output. (output: %d). Check display_get_outputs().", o); + } +} + +TEST_P(TDMBackendBasic, VerifyLayerObject) +{ + tdm_error ret; + int output_count = 0; + + ASSERT_TRUE(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE); + + for (int o = 0; o < output_count; o++) { + tdm_output *output = tdm_display_get_output(dpy, o, &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + + int layer_count = 0; + ASSERT_TRUE(tdm_output_get_layer_count(output, &layer_count) == TDM_ERROR_NONE); + TDM_UT_ASSERT_TRUE(layer_count > 0, + "layer count(%d) should be greater than 0. (output: %d). Check output_get_layers().", + layer_count, o); + + for (int l = 0; l < layer_count; l++) { + tdm_layer *layer = tdm_output_get_layer(output, l, &ret); + TDM_UT_ASSERT_TRUE(layer != NULL, "no layer. (output: %d, layer: %d). Check output_get_layers().", o, l); + } + } +} + +TEST_P(TDMBackendBasic, VerifyOutputGetProperty) +{ + tdm_error ret; + int output_count = 0; + + ASSERT_TRUE(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE); + + for (int o = 0; o < output_count; o++) { + tdm_output *output = tdm_display_get_output(dpy, o, &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + + const tdm_prop *props = NULL; + int prop_count = 0; + ASSERT_TRUE(tdm_output_get_available_properties(output, &props, &prop_count) == TDM_ERROR_NONE); + + if (prop_count > 0) + TDM_UT_ASSERT_TRUE(props != NULL, "no props. (output: %d). Check output_get_capability(), tdm_caps_output.", o); + + for (int p = 0; p < prop_count; p++) { + tdm_value value; + value.s32 = TDM_UT_INVALID_VALUE; + ASSERT_TRUE(tdm_output_get_property(output, props[p].id, &value) == TDM_ERROR_NONE); + TDM_UT_ASSERT_TRUE(value.s32 != TDM_UT_INVALID_VALUE, + "Getting a prop failed. (output: %d, prop_id: %d). Check output_get_property().", + o, props[p].id); + } + } +} + +TEST_P(TDMBackendBasic, VerifyLayerGetProperty) +{ + tdm_error ret; + int output_count = 0; + + ASSERT_TRUE(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE); + + for (int o = 0; o < output_count; o++) { + tdm_output *output = tdm_display_get_output(dpy, o, &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + + int layer_count = 0; + ASSERT_TRUE(tdm_output_get_layer_count(output, &layer_count) == TDM_ERROR_NONE); + + for (int l = 0; l < layer_count; l++) { + tdm_layer *layer = tdm_output_get_layer(output, l, &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + + const tdm_prop *props = NULL; + int prop_count = 0; + ASSERT_TRUE(tdm_layer_get_available_properties(layer, &props, &prop_count) == TDM_ERROR_NONE); + + if (prop_count > 0) + TDM_UT_ASSERT_TRUE(props != NULL, "no props. (output: %d, layer: %d). Check output_get_capability(), tdm_caps_output.", o, l); + + for (int p = 0; p < prop_count; p++) { + tdm_value value; + value.s32 = TDM_UT_INVALID_VALUE; + ASSERT_TRUE(tdm_layer_get_property(layer, props[p].id, &value) == TDM_ERROR_NONE); + TDM_UT_ASSERT_TRUE(value.s32 != TDM_UT_INVALID_VALUE, + "Getting a prop failed. (output: %d, layer: %d, prop_id: %d). Check output_get_property().", + o, l, props[p].id); + } + } + } +} + +TEST_P(TDMBackendBasic, VerifyOutputSetMode) +{ + for (int o = 0; o < output_count; o++) { + const tdm_output_mode *got_mode = NULL; + const tdm_output_mode *modes = (const tdm_output_mode *)TDM_UT_INVALID_VALUE; + const tdm_output_mode *set_mode = NULL; + const tdm_output_mode *best = NULL; + int count = TDM_UT_INVALID_VALUE; + + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(tdm_output_get_available_modes(outputs[o], &modes, &count) == TDM_ERROR_NONE); + TDM_UT_ASSERT_TRUE(count > 0, "mode's count should be greater than 0. Check output_get_capability(), tdm_caps_output."); + TDM_UT_ASSERT_TRUE(modes != NULL, "mode's count should be greater than 0. Check output_get_capability(), tdm_caps_output."); + + for (int i = 0; i < count; i++) { + if (!best) + best = &modes[i]; + if (modes[i].type & TDM_OUTPUT_MODE_TYPE_PREFERRED) + set_mode = &modes[i]; + } + if (!set_mode && best) + set_mode = best; + ASSERT_TRUE(set_mode != NULL); + + ASSERT_TRUE(tdm_output_set_mode(outputs[o], set_mode) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_get_mode(outputs[o], &got_mode) == TDM_ERROR_NONE); + TDM_UT_ASSERT_TRUE(set_mode == got_mode, "The mode which is set and got are different. Check output_set_mode(), output_get_mode()"); + } +} + +TEST_P(TDMBackendBasic, VerifyOutputSetDpms) +{ + for (int o = 0; o < output_count; o++) { + const tdm_output_mode *got_mode = NULL; + const tdm_output_mode *modes = (const tdm_output_mode *)TDM_UT_INVALID_VALUE; + const tdm_output_mode *set_mode = NULL; + const tdm_output_mode *best = NULL; + int count = TDM_UT_INVALID_VALUE; + tdm_output_dpms got_dpms = TDM_OUTPUT_DPMS_OFF; + tdm_output_dpms set_dpms = TDM_OUTPUT_DPMS_ON; + + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(tdm_output_get_available_modes(outputs[o], &modes, &count) == TDM_ERROR_NONE); + ASSERT_TRUE(count > 0); + ASSERT_TRUE(modes != NULL); + + for (int i = 0; i < count; i++) { + if (!best) + best = &modes[i]; + if (modes[i].type & TDM_OUTPUT_MODE_TYPE_PREFERRED) + set_mode = &modes[i]; + } + if (!set_mode && best) + set_mode = best; + + ASSERT_TRUE(set_mode != NULL); + ASSERT_TRUE(tdm_output_set_mode(outputs[o], set_mode) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_get_mode(outputs[o], &got_mode) == TDM_ERROR_NONE); + ASSERT_TRUE(set_mode == got_mode); + + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], set_dpms) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_get_dpms(outputs[o], &got_dpms) == TDM_ERROR_NONE); + TDM_UT_ASSERT_TRUE(set_dpms == got_dpms, "The dpms value which is set and got are different. Check output_set_dpms(), output_get_dpms()"); + } +} + +TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowOneFrame) +{ + for (int o = 0; o < output_count; o++) { + tdm_layer *layer; + + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + + layer = ut_tdm_output_get_primary_layer(outputs[o]); + ASSERT_TRUE(layer != NULL); + +retry: + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true) == true); + ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[0]) == true); + DestroyBuffers(); + + ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + + TDM_UT_ASK_YNR("* Successed to display a frame to a primary layer? (output: %d)", o); + + ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + + } +} + +TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowManyFrames) +{ + for (int o = 0; o < output_count; o++) { + tdm_layer *layer; + int next_buffer = 0; + + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + + layer = ut_tdm_output_get_primary_layer(outputs[o]); + ASSERT_TRUE(layer != NULL); + +retry: + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layer, buffers, 3, true) == true); + + /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ + for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { + ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]) == true); + ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + usleep(40000); /* 40 ms */ + next_buffer++; + if (next_buffer == 3) + next_buffer = 0; + } + + DestroyBuffers(); + + TDM_UT_ASK_YNR("* Successed to display many frames to a primary layer? (output: %d)", o); + + ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + } +} + +static void +_ut_tdm_backend_output_commit_cb(tdm_output *output, unsigned int sequence, + unsigned int tv_sec, unsigned int tv_usec, + void *user_data) +{ + bool *done = (bool*)user_data; + if (done) + *done = true; +} + +TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowOneFrameWithCommitHandler) +{ + for (int o = 0; o < output_count; o++) { + tdm_layer *layer; + + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + + layer = ut_tdm_output_get_primary_layer(outputs[o]); + ASSERT_TRUE(layer != NULL); + +retry: + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true) == true); + ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[0]) == true); + DestroyBuffers(); + + bool done = false; + TDM_UT_ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE, + "Check output_commit(), output_set_commit_handler()"); + while (!done) + TDM_UT_ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE, + "Check display_get_fd(), display_handle_events()"); + + TDM_UT_ASK_YNR("* Successed to display a frame to a primary layer? (output: %d)", o); + + ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + } +} + +TEST_P(TDMBackendBasic, VerifyOverlayLayersShowOneFrame) +{ + for (int o = 0; o < output_count; o++) { + tdm_layer *layer; + + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + + layer = ut_tdm_output_get_primary_layer(outputs[o]); + ASSERT_TRUE(layer != NULL); + + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layer, buffers, 1, false) == true); + ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[0]) == true); + DestroyBuffers(); + + ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + usleep(40000); /* 40 ms */ + +retry: + for (int l = 0; l < layer_count; l++) { + tdm_error ret; + + if (tdm_layer_get_output(layers[l], &ret) != outputs[o]) + continue; + ASSERT_TRUE(ret == TDM_ERROR_NONE); + if (ut_tdm_layer_is_primary_layer(layers[l])) + continue; + if (ut_tdm_layer_is_cursor_layer(layers[l])) + continue; + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 1, true) == true); + ASSERT_TRUE(ut_tdm_layer_set_buffer(layers[l], buffers[0]) == true); + DestroyBuffers(); + } + + ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + + TDM_UT_ASK_YNR("* Successed to display frames to all overlay layers? (output: %d)", o); + + for (int l = 0; l < layer_count; l++) + ASSERT_TRUE(tdm_layer_unset_buffer(layers[l]) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + } +} + +TEST_P(TDMBackendBasic, VerifyOverlayLayersShowManyFrames) +{ + for (int o = 0; o < output_count; o++) { + tdm_layer *layer; + + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + + layer = ut_tdm_output_get_primary_layer(outputs[o]); + ASSERT_TRUE(layer != NULL); + + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layer, buffers, 1, false) == true); + ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[0]) == true); + DestroyBuffers(); + + ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + usleep(40000); /* 40 ms */ + + for (int l = 0; l < layer_count; l++) { + tdm_error ret; + int next_buffer = 0; + + if (tdm_layer_get_output(layers[l], &ret) != outputs[o]) + continue; + ASSERT_TRUE(ret == TDM_ERROR_NONE); + if (ut_tdm_layer_is_primary_layer(layers[l])) + continue; + if (ut_tdm_layer_is_cursor_layer(layers[l])) + continue; + +retry: + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true) == true); + + /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ + for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { + ASSERT_TRUE(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer]) == true); + ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + usleep(40000); /* 40 ms */ + next_buffer++; + if (next_buffer == 3) + next_buffer = 0; + } + + DestroyBuffers(); + + TDM_UT_ASK_YNR("* Successed to display many frames to a layer? (output: %d, layer: %d)", o, l); + + ASSERT_TRUE(tdm_layer_unset_buffer(layers[l]) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + usleep(40000); /* 40 ms */ + } + } +} + +TEST_P(TDMBackendBasic, DISABLED_VerifyCursorLayer) +{ +} + +static void +_ut_tdm_backend_output_done_cb(tdm_output *output, unsigned int sequence, + unsigned int tv_sec, unsigned int tv_usec, + void *user_data) +{ + bool *done = (bool*)user_data; + if (done) + *done = true; +} + +TEST_P(TDMBackendBasic, VerifyOutputWaitVblank) +{ + for (int o = 0; o < output_count; o++) { + tdm_layer *layer; + + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + + layer = ut_tdm_output_get_primary_layer(outputs[o]); + ASSERT_TRUE(layer != NULL); + + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true) == true); + ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[0]) == true); + DestroyBuffers(); + + ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + + /* start from 1 */ + for (int t = 1; t < 10; t++) { + double start, end, interval; + bool done; + + interval = ut_tdm_output_get_vblank_interval_time(outputs[o]); + + done = false; + start = tdm_helper_get_time(); + TDM_UT_ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done) == TDM_ERROR_NONE, + "Check output_wait_vblank(), output_set_vblank_handler()"); + while (!done) + TDM_UT_ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE, + "Check display_get_fd(), display_handle_events()"); + end = tdm_helper_get_time(); + + /* "+ interval" consider the delay of socket communication between kernel and platform */ + TDM_UT_ASSERT_TRUE((end - start) > (interval * (t - 1)), + "The vblank event should happen after %d vsync intervals(%d ms).\n" + "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()", + t, (int)(t * interval * 1000), (int)((end - start) * 1000)); + TDM_UT_ASSERT_TRUE((end - start) < (interval * t + interval), + "The vblank event should happen after %d vsync intervals(%d ms).\n" + "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()", + t, (int)(t * interval * 1000), (int)((end - start) * 1000)); + + } + } +} + +TEST_P(TDMBackendBasic, VerifyOutputWaitVblankInterval) +{ + for (int o = 0; o < output_count; o++) { + tdm_layer *layer; + + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + + layer = ut_tdm_output_get_primary_layer(outputs[o]); + ASSERT_TRUE(layer != NULL); + + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true) == true); + ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[0]) == true); + DestroyBuffers(); + + ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + + /* start from 1 */ + for (int t = 1; t < 10; t++) { + double start, end, interval; + bool done; + + interval = ut_tdm_output_get_vblank_interval_time(outputs[o]); + + done = false; + start = tdm_helper_get_time(); + ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done) == TDM_ERROR_NONE); + while (!done) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + end = tdm_helper_get_time(); + + /* "+ interval" consider the delay of socket communication between kernel and platform */ + TDM_UT_ASSERT_TRUE((end - start) > (interval * (t - 1)), + "The vblank event should happen after %d vsync intervals(%d ms).\n" + "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()", + t, (int)(t * interval * 1000), (int)((end - start) * 1000)); + TDM_UT_ASSERT_TRUE((end - start) < (interval * t + interval), + "The vblank event should happen after %d vsync intervals(%d ms).\n" + "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()", + t, (int)(t * interval * 1000), (int)((end - start) * 1000)); + } + } +} + +TEST_P(TDMBackendBasic, VerifyOutputWaitVblankFewTimesInOneVblank) +{ + for (int o = 0; o < output_count; o++) { + tdm_layer *layer; + + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + + layer = ut_tdm_output_get_primary_layer(outputs[o]); + ASSERT_TRUE(layer != NULL); + + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true) == true); + ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[0]) == true); + DestroyBuffers(); + + ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + + /* start from 1 */ + for (int t = 1; t < 10; t++) { + double start, end, interval; + bool done1, done2, done3; + + interval = ut_tdm_output_get_vblank_interval_time(outputs[o]); + + done1 = done2 = done3 = false; + ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done1) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done2) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done3) == TDM_ERROR_NONE); + start = tdm_helper_get_time(); + while (!done1 || !done2 || !done3) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + end = tdm_helper_get_time(); + + /* "+ interval" consider the delay of socket communication between kernel and platform */ + TDM_UT_ASSERT_TRUE((end - start) > (interval * (t - 1)), + "The vblank event should happen after %d vsync intervals(%d ms).\n" + "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()", + t, (int)(t * interval * 1000), (int)((end - start) * 1000)); + TDM_UT_ASSERT_TRUE((end - start) < (interval * t + interval), + "The vblank event should happen after %d vsync intervals(%d ms).\n" + "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()", + t, (int)(t * interval * 1000), (int)((end - start) * 1000)); + } + } +} + +TEST_P(TDMBackendBasic, VerifyPPObject) +{ + tdm_error ret; + tdm_pp *pp; + + if (!ut_tdm_display_has_pp_capability(dpy)) { + TDM_UT_INFO("PP not supported"); + return; + } + + pp = tdm_display_create_pp(dpy, &ret); + TDM_UT_ASSERT_TRUE(ret == TDM_ERROR_NONE, "can't create a PP object. Check display_create_pp()"); + TDM_UT_ASSERT_TRUE(pp != NULL, "can't create a PP object. Check display_create_pp()"); + + tdm_pp_destroy(pp); +} + +TEST_P(TDMBackendBasic, VerifyPPCapabilities) +{ + tdm_pp_capability capabilities = (tdm_pp_capability)0; + + if (!ut_tdm_display_has_pp_capability(dpy)) { + TDM_UT_INFO("PP not supported"); + return; + } + + TDM_UT_ASSERT_TRUE(tdm_display_get_pp_capabilities(dpy, &capabilities) == TDM_ERROR_NONE, + "Check display_get_pp_capability(), tdm_caps_pp, tdm_pp_capability."); + TDM_UT_ASSERT_TRUE(capabilities != (tdm_pp_capability)0, + "PP has no capability. Check display_get_pp_capability(), tdm_caps_pp, tdm_pp_capability."); +} + +TEST_P(TDMBackendBasic, VerifyPPAvaiableSize) +{ + if (!ut_tdm_display_has_pp_capability(dpy)) { + TDM_UT_INFO("PP not supported"); + return; + } + + int min_w = 0; + int min_h = 0; + int max_w = 0; + int max_h = 0; + int preferred_align = 0; + ASSERT_TRUE(tdm_display_get_pp_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align) == TDM_ERROR_NONE); + ASSERT_TRUE(min_w != 0); + ASSERT_TRUE(min_h != 0); + ASSERT_TRUE(max_w != 0); + ASSERT_TRUE(max_h != 0); + ASSERT_TRUE(preferred_align != 0); +} + +TEST_P(TDMBackendBasic, VerifyPPAvaiableFormats) +{ + if (!ut_tdm_display_has_pp_capability(dpy)) { + TDM_UT_INFO("PP not supported"); + return; + } + + const tbm_format *formats = NULL; + int format_count = 0; + TDM_UT_ASSERT_TRUE(tdm_display_get_pp_available_formats(dpy, &formats, &format_count) == TDM_ERROR_NONE, + "Check display_get_pp_capability(), tdm_caps_pp"); + TDM_UT_ASSERT_TRUE(formats != NULL, "Should have a format table. Check display_get_pp_capability(), tdm_caps_pp."); + TDM_UT_ASSERT_TRUE(format_count > 0, "Format count should be greater than 0. Check display_get_pp_capability(), tdm_caps_pp."); +} + +TEST_P(TDMBackendBasic, VerifyCaptureObject) +{ + if (!ut_tdm_display_has_capture_capability(dpy)) { + TDM_UT_INFO("Capture not supported."); + return; + } + + for (int o = 0; o < output_count; o++) { + tdm_capture *capture; + tdm_error ret; + + unsigned int has_capability = 0; + ASSERT_TRUE(tdm_output_has_capture_capability(outputs[o], &has_capability) == TDM_ERROR_NONE); + if (!has_capability) { + TDM_UT_INFO("Capture not supported. (output: %d)", o); + continue; + } + + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + capture = tdm_output_create_capture(outputs[o], &ret); + TDM_UT_ASSERT_TRUE(ret == TDM_ERROR_NONE, "Can't create a capture object. Check output_create_capture()."); + TDM_UT_ASSERT_TRUE(capture != NULL, "Can't create a capture object. Check output_create_capture()."); + + tdm_capture_destroy(capture); + } +} + +TEST_P(TDMBackendBasic, VerifyCaptureAvaiableSize) +{ + if (!ut_tdm_display_has_capture_capability(dpy)) { + TDM_UT_INFO("Capture not supported."); + return; + } + + int min_w = 0; + int min_h = 0; + int max_w = 0; + int max_h = 0; + int preferred_align = 0; + ASSERT_TRUE(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align) == TDM_ERROR_NONE); + ASSERT_TRUE(min_w != 0); + ASSERT_TRUE(min_h != 0); + ASSERT_TRUE(max_w != 0); + ASSERT_TRUE(max_h != 0); + ASSERT_TRUE(preferred_align != 0); +} + +TEST_P(TDMBackendBasic, VerifyCaptureAvaiableFormats) +{ + if (!ut_tdm_display_has_capture_capability(dpy)) { + TDM_UT_INFO("Capture not supported."); + return; + } + + const tbm_format *formats = NULL; + int format_count = 0; + TDM_UT_ASSERT_TRUE(tdm_display_get_capture_available_formats(dpy, &formats, &format_count) == TDM_ERROR_NONE, + "Check display_get_capture_capability(), tdm_caps_capture."); + TDM_UT_ASSERT_TRUE(formats != NULL, "Should have a format table. Check display_get_capture_capability(), tdm_caps_capture."); + TDM_UT_ASSERT_TRUE(format_count > 0, "The format count should be greater than 0. Check display_get_capture_capability(), tdm_caps_capture."); +} + +#ifdef TDM_UT_TEST_WITH_PARAMS +INSTANTIATE_TEST_CASE_P(TDMBackendBasicParams, + TDMBackendBasic, + Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE))); +#else +INSTANTIATE_TEST_CASE_P(TDMBackendBasicParams, + TDMBackendBasic, + Values(TDM_DEFAULT_MODULE)); +#endif + +TEST_P(TDMBackendDisplay, VerifyPirmaryLayerFormat) +{ + for (int o = 0; o < output_count; o++) { + tdm_layer *layer; + int next_buffer = 0; + bool done = false; + tdm_error ret; + const tbm_format *formats; + int format_count = 0; + const tdm_output_mode *mode = NULL; + unsigned int flags = 0; + + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + layer = ut_tdm_output_get_primary_layer(outputs[o]); + ASSERT_TRUE(layer != NULL); + + ASSERT_TRUE(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_layer_get_available_formats(layer, &formats, &format_count) == TDM_ERROR_NONE); + + for (int f = 0; f < format_count; f++) { + ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_get_mode(outputs[o], &mode) == TDM_ERROR_NONE); + ASSERT_TRUE(mode != NULL); + +retry: + TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); + ASSERT_TRUE(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers) == true); + + /* set buffer & commit for 60 times */ + for (int t = 0; t < 60; t++) { + tbm_surface_h displaying_buffer; + ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]) == true); + done = false; + ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE); + while (!done) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_TRUE(displaying_buffer == buffers[next_buffer]); + next_buffer++; + if (next_buffer == 3) + next_buffer = 0; + } + + DestroyBuffers(); + + TDM_UT_ASK_YNR("* Successed to display '%c%c%c%c' frames to a primary layer? (output: %d)", FOURCC_STR(formats[f]), o); + } + } +} + +TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat) +{ + ASSERT_TRUE(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false) == true); + + for (int l = 0; l < layer_count; l++) { + tdm_error ret; + tdm_output *output; + tdm_layer *layer; + int next_buffer = 0; + bool done = false; + const tbm_format *formats; + int format_count = 0; + const tdm_output_mode *mode = NULL; + unsigned int flags = 0; + unsigned int pipe = 0; + + layer = layers[l]; + + output = tdm_layer_get_output(layer, &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + + if (!ut_tdm_output_is_connected(output)) + continue; + if (ut_tdm_layer_is_primary_layer(layer)) + continue; + if (ut_tdm_layer_is_cursor_layer(layer)) + continue; + + ASSERT_TRUE(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE); + + ASSERT_TRUE(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE); + ASSERT_TRUE(mode != NULL); + + ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + + ASSERT_TRUE(tdm_layer_get_available_formats(layer, &formats, &format_count) == TDM_ERROR_NONE); + + for (int f = 0; f < format_count; f++) { +retry: + TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); + ASSERT_TRUE(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers) == true); + + /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ + for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { + tbm_surface_h displaying_buffer; + ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]) == true); + done = false; + ASSERT_TRUE(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE); + while (!done) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_TRUE(displaying_buffer == buffers[next_buffer]); + next_buffer++; + if (next_buffer == 3) + next_buffer = 0; + } + + TDM_UT_ASK_YNR("* Successed to display '%c%c%c%c' frames to a layer? (output: %d, layer: %d)", FOURCC_STR(formats[f]), pipe, l); + + DestroyBuffers(); + } + + ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); + } +} + +TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize) +{ + ASSERT_TRUE(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false) == true); + + for (int l = 0; l < layer_count; l++) { + tdm_error ret; + tdm_output *output; + tdm_layer *layer; + int next_buffer = 0; + bool done = false; + const tbm_format *formats; + int format_count = 0; + const tdm_output_mode *mode = NULL; + unsigned int flags = 0; + unsigned int pipe = 0; + + layer = layers[l]; + + output = tdm_layer_get_output(layer, &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + + if (!ut_tdm_output_is_connected(output)) + continue; + if (ut_tdm_layer_is_primary_layer(layer)) + continue; + if (ut_tdm_layer_is_cursor_layer(layer)) + continue; + + ASSERT_TRUE(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE); + + ASSERT_TRUE(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE); + ASSERT_TRUE(mode != NULL); + + ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + + ASSERT_TRUE(tdm_layer_get_available_formats(layer, &formats, &format_count) == TDM_ERROR_NONE); + + for (int f = 0; f < format_count; f++) { + int diffw = mode->hdisplay / (format_count + 2); + int diffh = mode->vdisplay / (format_count + 2); + int w = mode->hdisplay - diffw * (f + 1); + int h = mode->vdisplay - diffh * (f + 1); +retry: + TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); + ASSERT_TRUE(ut_tdm_buffer_create(w, h, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers) == true); + + /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ + for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { + tbm_surface_h displaying_buffer; + ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]) == true); + done = false; + ASSERT_TRUE(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE); + while (!done) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_TRUE(displaying_buffer == buffers[next_buffer]); + next_buffer++; + if (next_buffer == 3) + next_buffer = 0; + } + + DestroyBuffers(); + + TDM_UT_ASK_YNR("* Successed to display '%c%c%c%c' small size(%dx%d) frames to a layer? (output: %d, layer: %d)", + FOURCC_STR(formats[f]), w, h, pipe, l); + } + + ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); + } +} + +TEST_P(TDMBackendDisplay, VerifyOverlayLayerScale) +{ + ASSERT_TRUE(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false) == true); + + for (int l = 0; l < layer_count; l++) { + tdm_error ret; + tdm_output *output; + tdm_layer *layer; + int next_buffer = 0; + bool done = false; + const tbm_format *formats; + int format_count = 0; + const tdm_output_mode *mode = NULL; + unsigned int flags = 0; + unsigned int pipe = 0; + + layer = layers[l]; + + output = tdm_layer_get_output(layer, &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + + ASSERT_TRUE(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE); + + if (!ut_tdm_output_is_connected(output)) + continue; + if (ut_tdm_layer_is_primary_layer(layer)) + continue; + if (ut_tdm_layer_is_cursor_layer(layer)) + continue; + if (!ut_tdm_layer_support_scale(layer)) { + TDM_UT_INFO("no scale capability. (output: %d, layer: %d)", pipe, l); + continue; + } + + ASSERT_TRUE(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE); + ASSERT_TRUE(mode != NULL); + + ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + + ASSERT_TRUE(tdm_layer_get_available_formats(layer, &formats, &format_count) == TDM_ERROR_NONE); + + for (int f = 0; f < format_count; f++) { +retry: + TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); + ASSERT_TRUE(ut_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers) == true); + + tdm_info_layer info; + memset(&info, 0, sizeof info); + info.src_config.size.h = TDM_UT_BUFFER_SIZE; + info.src_config.size.v = TDM_UT_BUFFER_SIZE; + info.src_config.pos.x = 0; + info.src_config.pos.y = 0; + info.src_config.pos.w = TDM_UT_BUFFER_SIZE; + info.src_config.pos.h = TDM_UT_BUFFER_SIZE; + info.src_config.format = formats[f]; + info.dst_pos.x = 0; + info.dst_pos.y = 0; + info.dst_pos.w = mode->hdisplay; + info.dst_pos.h = mode->vdisplay; + info.transform = TDM_TRANSFORM_NORMAL; + ASSERT_TRUE(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE); + + /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ + for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { + tbm_surface_h displaying_buffer; + ASSERT_TRUE(tdm_layer_set_buffer(layer, buffers[next_buffer]) == TDM_ERROR_NONE); + done = false; + ASSERT_TRUE(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE); + while (!done) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_TRUE(displaying_buffer == buffers[next_buffer]); + next_buffer++; + if (next_buffer == 3) + next_buffer = 0; + } + + DestroyBuffers(); + + TDM_UT_ASK_YNR("* Successed to scale '%c%c%c%c' small size(%dx%d) frames to fullsreen? (output: %d, layer: %d)", + FOURCC_STR(formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, pipe, l); + } + + ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); + } +} + +TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition) +{ + ASSERT_TRUE(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false) == true); + + for (int l = 0; l < layer_count; l++) { + tdm_error ret; + tdm_output *output; + tdm_layer *layer; + int next_buffer = 0; + bool done = false; + const tbm_format *formats; + int format_count = 0; + const tdm_output_mode *mode = NULL; + unsigned int flags = 0; + unsigned int pipe = 0; + + layer = layers[l]; + + output = tdm_layer_get_output(layer, &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + + if (!ut_tdm_output_is_connected(output)) + continue; + if (ut_tdm_layer_is_primary_layer(layer)) + continue; + if (ut_tdm_layer_is_cursor_layer(layer)) + continue; + + ASSERT_TRUE(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE); + + ASSERT_TRUE(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE); + ASSERT_TRUE(mode != NULL); + + ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + + ASSERT_TRUE(tdm_layer_get_available_formats(layer, &formats, &format_count) == TDM_ERROR_NONE); + + for (int f = 0; f < format_count; f++) { +retry: + TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); + ASSERT_TRUE(ut_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers) == true); + + /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ + for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { + tbm_surface_h displaying_buffer; + + tdm_info_layer info; + memset(&info, 0, sizeof info); + info.src_config.size.h = TDM_UT_BUFFER_SIZE; + info.src_config.size.v = TDM_UT_BUFFER_SIZE; + info.src_config.pos.x = 0; + info.src_config.pos.y = 0; + info.src_config.pos.w = TDM_UT_BUFFER_SIZE; + info.src_config.pos.h = TDM_UT_BUFFER_SIZE; + info.src_config.format = formats[f]; + info.dst_pos.x = ((mode->hdisplay - TDM_UT_BUFFER_SIZE) / TDM_UT_BACKEND_TEST_CNT) * t; + info.dst_pos.y = ((mode->vdisplay - TDM_UT_BUFFER_SIZE) / TDM_UT_BACKEND_TEST_CNT) * t; + info.dst_pos.w = TDM_UT_BUFFER_SIZE; + info.dst_pos.h = TDM_UT_BUFFER_SIZE; + info.transform = TDM_TRANSFORM_NORMAL; + ASSERT_TRUE(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE); + + ASSERT_TRUE(tdm_layer_set_buffer(layer, buffers[next_buffer]) == TDM_ERROR_NONE); + done = false; + ASSERT_TRUE(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE); + while (!done) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_TRUE(displaying_buffer == buffers[next_buffer]); + next_buffer++; + if (next_buffer == 3) + next_buffer = 0; + } + + DestroyBuffers(); + + TDM_UT_ASK_YNR("* Successed to move '%c%c%c%c' small size(%dx%d) frames on screen? (output: %d, layer: %d)", + FOURCC_STR(formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, pipe, l); + } + + ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); + } +} + +TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop) +{ + ASSERT_TRUE(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false) == true); + + for (int l = 0; l < layer_count; l++) { + tdm_error ret; + tdm_output *output; + tdm_layer *layer; + int next_buffer = 0; + bool done = false; + const tbm_format *formats; + int format_count = 0; + const tdm_output_mode *mode = NULL; + unsigned int flags = 0; + unsigned int pipe = 0; + + layer = layers[l]; + + output = tdm_layer_get_output(layer, &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + + ASSERT_TRUE(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE); + + if (!ut_tdm_output_is_connected(output)) + continue; + if (ut_tdm_layer_is_primary_layer(layer)) + continue; + if (ut_tdm_layer_is_cursor_layer(layer)) + continue; + if (ut_tdm_layer_support_no_crop(layer)) { + TDM_UT_INFO("no crop capability. (output: %d, layer: %d)", pipe, l); + continue; + } + + ASSERT_TRUE(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE); + ASSERT_TRUE(mode != NULL); + + ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + + ASSERT_TRUE(tdm_layer_get_available_formats(layer, &formats, &format_count) == TDM_ERROR_NONE); + + for (int f = 0; f < format_count; f++) { +retry: + TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); + ASSERT_TRUE(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers) == true); + + tdm_info_layer info; + memset(&info, 0, sizeof info); + info.src_config.size.h = mode->hdisplay; + info.src_config.size.v = mode->vdisplay; + info.src_config.pos.x = mode->hdisplay / 2; + info.src_config.pos.y = mode->vdisplay / 2; + info.src_config.pos.w = info.src_config.size.h / 2; + info.src_config.pos.h = info.src_config.size.v / 2; + info.src_config.format = formats[f]; + info.dst_pos.x = info.src_config.pos.x; + info.dst_pos.y = info.src_config.pos.y; + info.dst_pos.w = info.src_config.pos.w; + info.dst_pos.h = info.src_config.pos.h; + info.transform = TDM_TRANSFORM_NORMAL; + ASSERT_TRUE(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE); + + /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ + for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { + tbm_surface_h displaying_buffer; + ASSERT_TRUE(tdm_layer_set_buffer(layer, buffers[next_buffer]) == TDM_ERROR_NONE); + done = false; + ASSERT_TRUE(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE); + while (!done) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_TRUE(displaying_buffer == buffers[next_buffer]); + next_buffer++; + if (next_buffer == 3) + next_buffer = 0; + } + + DestroyBuffers(); + + TDM_UT_ASK_YNR("* Successed to crop '%c%c%c%c' frames and display it? (output: %d, layer: %d)", + FOURCC_STR(formats[f]), pipe, l); + } + + ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); + } +} + +/* should be debugged int emulator kernel */ +TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOnToOff) +{ + ASSERT_TRUE(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true) == true); + + for (int o = 0; o < output_count; o++) { + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + } +} + +/* should be debugged int emulator kernel */ +TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOffToOn) +{ + ASSERT_TRUE(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true) == true); + + for (int o = 0; o < output_count; o++) { + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + } +} + +/* should be debugged int emulator kernel */ +TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOnBeforeSet) +{ + for (int o = 0; o < output_count; o++) { + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + } +} + +/* should be debugged int emulator kernel */ +TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffBeforeSet) +{ + for (int o = 0; o < output_count; o++) { + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + } +} + +/* should be debugged int emulator kernel */ +TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithoutCommit) +{ + for (int o = 0; o < output_count; o++) { + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + + tdm_layer *layer = ut_tdm_output_get_primary_layer(outputs[o]); + ASSERT_TRUE(layer != NULL); + + ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); + + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + } +} + +/* should be debugged int emulator kernel */ +TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithCommit) +{ + for (int o = 0; o < output_count; o++) { + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + + tdm_layer *layer = ut_tdm_output_get_primary_layer(outputs[o]); + ASSERT_TRUE(layer != NULL); + + ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + } +} + +TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsAsync) +{ +} + +TEST_P(TDMBackendDisplay, VerifyLayerGetInfo) +{ + ASSERT_TRUE(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true) == true); + + for (int o = 0; o < output_count; o++) { + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + tdm_info_layer info, temp; + tdm_layer *layer = ut_tdm_output_get_primary_layer(outputs[o]); + ASSERT_TRUE(layer != NULL); + ASSERT_TRUE(ut_tdm_layer_fill_info(layer, -1, -1, 0, &info) == true); + ASSERT_TRUE(tdm_layer_get_info(layer, &temp) == TDM_ERROR_NONE); + ASSERT_TRUE(memcmp(&info, &temp, sizeof info) == 0); + } +} + +TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputWaitVblankBeforeDpmsOff) /* TODO */ +{ +} + +TEST_P(TDMBackendDisplay, DISABLED_VerifyLayerSetVideoPos) +{ +} + +#ifdef TDM_UT_TEST_WITH_PARAMS +INSTANTIATE_TEST_CASE_P(TDMBackendDisplayParams, + TDMBackendDisplay, + Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE))); +#else +INSTANTIATE_TEST_CASE_P(TDMBackendDisplayParams, + TDMBackendDisplay, + Values(TDM_DEFAULT_MODULE)); +#endif diff --git a/utests/src/ut_tdm_backend_env.cpp b/utests/src/ut_tdm_backend_env.cpp new file mode 100644 index 0000000..4c9bbbf --- /dev/null +++ b/utests/src/ut_tdm_backend_env.cpp @@ -0,0 +1,79 @@ +/************************************************************************** + * + * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved. + * + * Contact: Konstantin Drabeniuk + * Contact: Andrii Sokolenko + * Contact: Roman Marchenko + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sub license, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial portions + * of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. + * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR + * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * +**************************************************************************/ + +#include "ut_tdm.h" + +bool enable_porting_debug = false; + +void TDMBackendEnv::SetUp(void) +{ + const char *debug; + + TDMEnv::SetUp(); + + /* thread, commit_per_vblank should be turned off for testing TDMBackend + * all TDMBackend's tcs should call tdm_output_commit once in a vblank. + * don't call tdm_layer_commit. + */ + tdm_config_set_int(TDM_CONFIG_KEY_GENERAL_THREAD, 0); + tdm_config_set_int(TDM_CONFIG_KEY_GENERAL_COMMIT_PER_VBLANK, 0); + + debug = getenv("TDM_UT_DEBUG_BACKEND"); + if (debug && (debug[0] == '1')) + enable_porting_debug = true; +} + +void TDMBackendEnv::TearDown(void) +{ + TDMEnv::TearDown(); +} + +TEST_P(TDMBackendEnv, VerifyDisplay) +{ + tdm_display *dpy; + tdm_error ret; + + dpy = tdm_display_init(&ret); + TDM_UT_ASSERT_TRUE(dpy != NULL, "display init failed: %s", tdm_error_str(ret)); + + TDM_UT_INFO("display init success"); + + tdm_display_deinit(dpy); +} + +#ifdef TDM_UT_TEST_WITH_PARAMS +INSTANTIATE_TEST_CASE_P(TDMBackendEnvParams, + TDMBackendEnv, + Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE))); +#else +INSTANTIATE_TEST_CASE_P(TDMBackendEnvParams, + TDMBackendEnv, + Values(TDM_DEFAULT_MODULE)); +#endif diff --git a/utests/src/ut_tdm_pp.cpp b/utests/src/ut_tdm_backend_pp.cpp similarity index 64% rename from utests/src/ut_tdm_pp.cpp rename to utests/src/ut_tdm_backend_pp.cpp index a2d1b65..dcc7fb7 100644 --- a/utests/src/ut_tdm_pp.cpp +++ b/utests/src/ut_tdm_backend_pp.cpp @@ -30,7 +30,8 @@ #include "ut_tdm.h" -class TDMPP : public TDMDisplay { +class TDMBackendPP : public TDMBackendDisplay +{ public: tdm_pp *pp; tdm_pp_capability capabilities; @@ -47,16 +48,18 @@ public: tdm_info_pp info; - TDMPP(); + TDMBackendPP(); void SetUp(void); void TearDown(void); - bool TestPrepare(int sw, int sh, tbm_format sf, int dw, int dh, tbm_format df, tdm_transform t); + bool PreparePP(void); + bool PrepareBuffers(int sw, int sh, tbm_format sf, int dw, int dh, tbm_format df, tdm_transform t); void DumpBuffers(int b, char *test); void DestroyBuffers(void); + void DestroyPP(void); }; -TDMPP::TDMPP() +TDMBackendPP::TDMBackendPP() { pp = NULL; capabilities = (tdm_pp_capability)0; @@ -69,17 +72,10 @@ TDMPP::TDMPP() memset(&info, 0, sizeof info); } -void TDMPP::SetUp(void) +void TDMBackendPP::SetUp(void) { - TDMDisplay::SetUp(); - - if (!has_pp_cap) - return; + TDMBackendDisplay::SetUp(); - tdm_error ret; - pp = tdm_display_create_pp(dpy, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(pp != NULL); ASSERT_TRUE(tdm_display_get_pp_capabilities(dpy, &capabilities) == TDM_ERROR_NONE); ASSERT_TRUE(capabilities > 0); ASSERT_TRUE(tdm_display_get_pp_available_formats(dpy, &formats, &format_count) == TDM_ERROR_NONE); @@ -93,17 +89,34 @@ void TDMPP::SetUp(void) ASSERT_TRUE(preferred_align == -1 || preferred_align > 0); } -void TDMPP::TearDown(void) +void TDMBackendPP::TearDown(void) { if (pp) tdm_pp_destroy(pp); DestroyBuffers(); - TDMDisplay::TearDown(); + TDMBackendDisplay::TearDown(); } -bool TDMPP::TestPrepare(int sw, int sh, tbm_format sf, int dw, int dh, tbm_format df, tdm_transform t) +bool TDMBackendPP::PreparePP(void) +{ + tdm_error ret; + pp = tdm_display_create_pp(dpy, &ret); + TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE); + TDM_UT_RETURN_FALSE_IF_FAIL(pp != NULL); + return true; +} + +void TDMBackendPP::DestroyPP(void) +{ + if (pp) { + tdm_pp_destroy(pp); + pp = NULL; + } +} + +bool TDMBackendPP::PrepareBuffers(int sw, int sh, tbm_format sf, int dw, int dh, tbm_format df, tdm_transform t) { int flags = 0; @@ -121,7 +134,7 @@ bool TDMPP::TestPrepare(int sw, int sh, tbm_format sf, int dw, int dh, tbm_forma return true; } -void TDMPP::DumpBuffers(int b, char *test) +void TDMBackendPP::DumpBuffers(int b, char *test) { char filename[256]; if (test) @@ -136,11 +149,13 @@ void TDMPP::DumpBuffers(int b, char *test) tdm_helper_dump_buffer_str(dstbuf[b], NULL, filename); } -void TDMPP::DestroyBuffers(void) +void TDMBackendPP::DestroyBuffers(void) { for (int b = 0; b < 3; b++) { - tbm_surface_destroy(srcbuf[b]); - tbm_surface_destroy(dstbuf[b]); + if (srcbuf[b]) + tbm_surface_destroy(srcbuf[b]); + if (dstbuf[b]) + tbm_surface_destroy(dstbuf[b]); srcbuf[b] = dstbuf[b] = NULL; } } @@ -185,10 +200,10 @@ ut_tdm_pp_fill_info(tbm_surface_h srcbuf, tbm_surface_h dstbuf, tdm_transform tr info->flags = 0; TDM_INFO("src_config(%dx%d: %d,%d %dx%d: %c%c%c%c) dst_config(%dx%d: %d,%d %dx%d: %c%c%c%c) transform(%s) sync(%d) info->flags(%x)", - info->src_config.size.h, info->src_config.size.h, + info->src_config.size.h, info->src_config.size.v, info->src_config.pos.x, info->src_config.pos.y, info->src_config.pos.w, info->src_config.pos.h, FOURCC_STR(info->src_config.format), - info->dst_config.size.h, info->dst_config.size.h, + info->dst_config.size.h, info->dst_config.size.v, info->dst_config.pos.x, info->dst_config.pos.y, info->dst_config.pos.w, info->dst_config.pos.h, FOURCC_STR(info->dst_config.format), tdm_transform_str(transform), info->sync, info->flags); @@ -196,13 +211,11 @@ ut_tdm_pp_fill_info(tbm_surface_h srcbuf, tbm_surface_h dstbuf, tdm_transform tr return true; } -#ifdef UT_TDM_PP_ENABLE - -TEST_P(TDMPP, PPDispalyGetAvaiableFormatsNullObject) +TEST_P(TDMBackendPP, PPDispalyGetAvaiableFormatsNullObject) { const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; - if (has_pp_cap) + if (ut_tdm_display_has_pp_capability(dpy)) ASSERT_TRUE(tdm_display_get_pp_available_formats(NULL, &formats, &count) == TDM_ERROR_INVALID_PARAMETER); else ASSERT_TRUE(tdm_display_get_pp_available_formats(NULL, &formats, &count) == TDM_ERROR_NO_CAPABILITY); @@ -210,22 +223,22 @@ TEST_P(TDMPP, PPDispalyGetAvaiableFormatsNullObject) ASSERT_TRUE(count == TDM_UT_INVALID_VALUE); } -TEST_P(TDMPP, PPDispalyGetAvaiableFormatsNullOther) +TEST_P(TDMBackendPP, PPDispalyGetAvaiableFormatsNullOther) { - if (has_pp_cap) + if (ut_tdm_display_has_pp_capability(dpy)) { + ASSERT_TRUE(PreparePP() == true); ASSERT_TRUE(tdm_display_get_pp_available_formats(pp, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); - else - ASSERT_TRUE(tdm_display_get_pp_available_formats(pp, NULL, NULL) == TDM_ERROR_NO_CAPABILITY); + } } -TEST_P(TDMPP, PPDispalyGetAvaiableSizeNullObject) +TEST_P(TDMBackendPP, PPDispalyGetAvaiableSizeNullObject) { int min_w = TDM_UT_INVALID_VALUE; int min_h = TDM_UT_INVALID_VALUE; int max_w = TDM_UT_INVALID_VALUE; int max_h = TDM_UT_INVALID_VALUE; int preferred_align = TDM_UT_INVALID_VALUE; - if (has_pp_cap) + if (ut_tdm_display_has_pp_capability(dpy)) ASSERT_TRUE(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align) == TDM_ERROR_INVALID_PARAMETER); else ASSERT_TRUE(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align) == TDM_ERROR_NO_CAPABILITY); @@ -236,47 +249,49 @@ TEST_P(TDMPP, PPDispalyGetAvaiableSizeNullObject) ASSERT_TRUE(preferred_align == TDM_UT_INVALID_VALUE); } -TEST_P(TDMPP, PPDispalyGetAvaiableSizeNullOther) +TEST_P(TDMBackendPP, PPDispalyGetAvaiableSizeNullOther) { - if (has_pp_cap) + if (ut_tdm_display_has_pp_capability(dpy)) { + ASSERT_TRUE(PreparePP() == true); ASSERT_TRUE(tdm_display_get_pp_available_size(pp, NULL, NULL, NULL, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); - else - ASSERT_TRUE(tdm_display_get_pp_available_size(pp, NULL, NULL, NULL, NULL, NULL) == TDM_ERROR_NO_CAPABILITY); + } } -TEST_P(TDMPP, PPDestroy) +TEST_P(TDMBackendPP, PPDestroy) { - TDM_UT_SKIP_FLAG(has_pp_cap); + TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + ASSERT_TRUE(PreparePP() == true); tdm_pp_destroy(pp); pp = NULL; } -TEST_P(TDMPP, PPDestroyNullObject) +TEST_P(TDMBackendPP, PPDestroyNullObject) { - TDM_UT_SKIP_FLAG(has_pp_cap); + TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); tdm_pp_destroy(NULL); } -TEST_P(TDMPP, PPSetInfo) +TEST_P(TDMBackendPP, PPSetInfo) { /* tested in PPNoScaleNoTransformNoCSC */ } -TEST_P(TDMPP, PPSetInfoNullObject) +TEST_P(TDMBackendPP, PPSetInfoNullObject) { - TDM_UT_SKIP_FLAG(has_pp_cap); + TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); tdm_info_pp info; memset(&info, 0, sizeof info); ASSERT_TRUE(tdm_pp_set_info(NULL, &info) == TDM_ERROR_INVALID_PARAMETER); } -TEST_P(TDMPP, PPSetInfoNullOther) +TEST_P(TDMBackendPP, PPSetInfoNullOther) { - TDM_UT_SKIP_FLAG(has_pp_cap); + TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + ASSERT_TRUE(PreparePP() == true); ASSERT_TRUE(tdm_pp_set_info(pp, NULL) == TDM_ERROR_INVALID_PARAMETER); } @@ -288,35 +303,39 @@ _ut_tdm_pp_done_cb(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst, void *user_ *done = true; } -TEST_P(TDMPP, PPSetDoneHandler) +TEST_P(TDMBackendPP, PPSetDoneHandler) { - TDM_UT_SKIP_FLAG(has_pp_cap); + TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + ASSERT_TRUE(PreparePP() == true); ASSERT_TRUE(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, NULL) == TDM_ERROR_NONE); } -TEST_P(TDMPP, PPSetDoneHandlerNullObject) +TEST_P(TDMBackendPP, PPSetDoneHandlerNullObject) { - TDM_UT_SKIP_FLAG(has_pp_cap); + TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); ASSERT_TRUE(tdm_pp_set_done_handler(NULL, _ut_tdm_pp_done_cb, NULL) == TDM_ERROR_INVALID_PARAMETER); } -TEST_P(TDMPP, PPSetDoneHandlerNullOther) +TEST_P(TDMBackendPP, PPSetDoneHandlerNullOther) { - TDM_UT_SKIP_FLAG(has_pp_cap); + TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + ASSERT_TRUE(PreparePP() == true); ASSERT_TRUE(tdm_pp_set_done_handler(pp, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); } -TEST_P(TDMPP, PPAttach) +TEST_P(TDMBackendPP, PPAttach) { - TDM_UT_SKIP_FLAG(has_pp_cap); + TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + + ASSERT_TRUE(PreparePP() == true); for (int f = 0; f < format_count; f++) { - ASSERT_TRUE(TestPrepare(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_TRANSFORM_NORMAL) == true); + ASSERT_TRUE(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + TDM_TRANSFORM_NORMAL) == true); for (int b = 0; b < 3; b++) ASSERT_TRUE(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]) == TDM_ERROR_NONE); @@ -325,9 +344,9 @@ TEST_P(TDMPP, PPAttach) } } -TEST_P(TDMPP, PPAttachNullObject) +TEST_P(TDMBackendPP, PPAttachNullObject) { - TDM_UT_SKIP_FLAG(has_pp_cap); + TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); tbm_surface_h srcbuf = (tbm_surface_h)TDM_UT_BUFFER_SIZE; tbm_surface_h dstbuf = (tbm_surface_h)TDM_UT_BUFFER_SIZE; @@ -335,64 +354,70 @@ TEST_P(TDMPP, PPAttachNullObject) ASSERT_TRUE(tdm_pp_attach(NULL, srcbuf, dstbuf) == TDM_ERROR_INVALID_PARAMETER); } -TEST_P(TDMPP, PPAttachNullOther) +TEST_P(TDMBackendPP, PPAttachNullOther) { - TDM_UT_SKIP_FLAG(has_pp_cap); + TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + + ASSERT_TRUE(PreparePP() == true); ASSERT_TRUE(tdm_pp_attach(pp, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); } -TEST_P(TDMPP, PPCommit) +TEST_P(TDMBackendPP, PPCommit) { - TDM_UT_SKIP_FLAG(has_pp_cap); + TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + + ASSERT_TRUE(PreparePP() == true); ASSERT_TRUE(tdm_pp_commit(pp) == TDM_ERROR_NONE); } -TEST_P(TDMPP, PPCommitNullOBject) +TEST_P(TDMBackendPP, PPCommitNullOBject) { - TDM_UT_SKIP_FLAG(has_pp_cap); + TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); ASSERT_TRUE(tdm_pp_commit(NULL) == TDM_ERROR_INVALID_PARAMETER); } -TEST_P(TDMPP, PPNoScaleNoTransformNoCSC) +TEST_P(TDMBackendPP, PPNoScaleNoTransformNoCSC) { - TDM_UT_SKIP_FLAG(has_pp_cap); + TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); bool done; + char temp[256]; + snprintf(temp, sizeof temp, "%c%c%c%c", FOURCC_STR(formats[0])); - for (int f = 0; f < format_count; f++) { - char temp[256]; - snprintf(temp, sizeof temp, "%c%c%c%c", FOURCC_STR(formats[f])); - - TDM_INFO("---- format(%c%c%c%c)", FOURCC_STR(formats[f])); + TDM_INFO("---- format(%c%c%c%c)", FOURCC_STR(formats[0])); - ASSERT_TRUE(TestPrepare(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, formats[2], - TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, formats[0], - TDM_TRANSFORM_NORMAL) == true); + ASSERT_TRUE(PreparePP() == true); - ASSERT_TRUE(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done) == TDM_ERROR_NONE); + ASSERT_TRUE(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, formats[0], + TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, formats[0], + TDM_TRANSFORM_NORMAL) == true); - for (int b = 0; b < 3; b++) { - done = false; + ASSERT_TRUE(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_pp_commit(pp) == TDM_ERROR_NONE); + for (int b = 0; b < 3; b++) { + done = false; - while (!done) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_pp_commit(pp) == TDM_ERROR_NONE); - DumpBuffers(b, temp); - } + while (!done) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); - DestroyBuffers(); + DumpBuffers(b, temp); } + + DestroyPP(); + DestroyBuffers(); } -TEST_P(TDMPP, PPScaleTransformCSC) +TEST_P(TDMBackendPP, PPScaleTransformCSC) { - TDM_UT_SKIP_FLAG(has_pp_cap); + TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + + ASSERT_TRUE(PreparePP() == true); bool done; tbm_format format1, format2; @@ -403,11 +428,11 @@ TEST_P(TDMPP, PPScaleTransformCSC) else format2 = formats[0]; - TDM_INFO("format(%c%c%c%c) ------> format(%c%c%c%c)", format1, format2); + TDM_INFO("format(%c%c%c%c) ------> format(%c%c%c%c)", FOURCC_STR(format1), FOURCC_STR(format2)); - ASSERT_TRUE(TestPrepare(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, format1, - TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, format2, - TDM_TRANSFORM_NORMAL) == true); + ASSERT_TRUE(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, format1, + TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, format2, + TDM_TRANSFORM_NORMAL) == true); ASSERT_TRUE(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done) == TDM_ERROR_NONE); @@ -418,7 +443,7 @@ TEST_P(TDMPP, PPScaleTransformCSC) ASSERT_TRUE(tdm_pp_commit(pp) == TDM_ERROR_NONE); while (!done) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); DumpBuffers(b, NULL); } @@ -434,18 +459,21 @@ _ut_tdm_pp_done_cb2(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst, void *user (*done)++; } -TEST_P(TDMPP, PPAttachFewTimesInOneCommit) +/* some backend doens't implement correctly for attaching */ +TEST_P(TDMBackendPP, DISABLED_PPAttachFewTimesInOneCommit) { - TDM_UT_SKIP_FLAG(has_pp_cap); + TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + + ASSERT_TRUE(PreparePP() == true); int done = 0; int f = 0; char temp[256]; snprintf(temp, sizeof temp, "%c%c%c%c", FOURCC_STR(formats[f])); - ASSERT_TRUE(TestPrepare(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_TRANSFORM_NORMAL) == true); + ASSERT_TRUE(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + TDM_TRANSFORM_NORMAL) == true); ASSERT_TRUE(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb2, &done) == TDM_ERROR_NONE); for (int b = 0; b < 3; b++) @@ -454,7 +482,7 @@ TEST_P(TDMPP, PPAttachFewTimesInOneCommit) ASSERT_TRUE(tdm_pp_commit(pp) == TDM_ERROR_NONE); while (done != 3) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); for (int b = 0; b < 3; b++) DumpBuffers(b, temp); @@ -462,15 +490,17 @@ TEST_P(TDMPP, PPAttachFewTimesInOneCommit) DestroyBuffers(); } -TEST_P(TDMPP, PPDestroyWithoutCommit) +TEST_P(TDMBackendPP, PPDestroyWithoutCommit) { - TDM_UT_SKIP_FLAG(has_pp_cap); + TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + + ASSERT_TRUE(PreparePP() == true); int f = 0; - ASSERT_TRUE(TestPrepare(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_TRANSFORM_NORMAL) == true); + ASSERT_TRUE(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + TDM_TRANSFORM_NORMAL) == true); ASSERT_TRUE(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb2, NULL) == TDM_ERROR_NONE); for (int b = 0; b < 3; b++) @@ -482,15 +512,17 @@ TEST_P(TDMPP, PPDestroyWithoutCommit) DestroyBuffers(); } -TEST_P(TDMPP, PPDestroyBeforeDone) +TEST_P(TDMBackendPP, PPDestroyBeforeDone) { - TDM_UT_SKIP_FLAG(has_pp_cap); + TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + + ASSERT_TRUE(PreparePP() == true); int f = 0; - ASSERT_TRUE(TestPrepare(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_TRANSFORM_NORMAL) == true); + ASSERT_TRUE(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + TDM_TRANSFORM_NORMAL) == true); ASSERT_TRUE(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb2, NULL) == TDM_ERROR_NONE); for (int b = 0; b < 3; b++) @@ -504,8 +536,12 @@ TEST_P(TDMPP, PPDestroyBeforeDone) DestroyBuffers(); } -INSTANTIATE_TEST_CASE_P(TDMPPParams, - TDMPP, +#ifdef TDM_UT_TEST_WITH_PARAMS +INSTANTIATE_TEST_CASE_P(TDMBackendPPParams, + TDMBackendPP, Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE))); - +#else +INSTANTIATE_TEST_CASE_P(TDMBackendPPParams, + TDMBackendPP, + Values(TDM_DEFAULT_MODULE)); #endif diff --git a/utests/src/ut_tdm_buffer.cpp b/utests/src/ut_tdm_buffer.cpp index 71d14e9..97fcf31 100644 --- a/utests/src/ut_tdm_buffer.cpp +++ b/utests/src/ut_tdm_buffer.cpp @@ -63,6 +63,9 @@ void TDMBuffer::TearDown(void) bool ut_tdm_buffer_create(int width, int height, tbm_format format, int flags, bool fill, int count, tbm_surface_h *buffers) { + TDM_UT_GOTO_IF_FAIL(width > 0, failed); + TDM_UT_GOTO_IF_FAIL(height > 0, failed); + for (int b = 0; b < count; b++) { buffers[b] = tbm_surface_internal_create_with_flags(width, height, format, flags); TDM_UT_GOTO_IF_FAIL(buffers[b] != NULL, failed); @@ -84,8 +87,6 @@ failed: return false; } -#ifdef UT_TDM_BUFFER_ENABLE - TEST_P(TDMBuffer, BufferRefBackend) { ASSERT_TRUE(tdm_buffer_ref_backend(buffer) == buffer); @@ -282,8 +283,12 @@ TEST_P(TDMBuffer, BufferRemoveReleaseHandlerNoAdd) tdm_buffer_remove_release_handler(buffer, _ut_tdm_buffer_release_cb, NULL); } +#ifdef TDM_UT_TEST_WITH_PARAMS INSTANTIATE_TEST_CASE_P(TDMBufferParams, TDMBuffer, Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE))); - +#else +INSTANTIATE_TEST_CASE_P(TDMBufferParams, + TDMBuffer, + Values(TDM_DEFAULT_MODULE)); #endif diff --git a/utests/src/ut_tdm_client.cpp b/utests/src/ut_tdm_client.cpp index b8f5793..2fd8db0 100644 --- a/utests/src/ut_tdm_client.cpp +++ b/utests/src/ut_tdm_client.cpp @@ -40,6 +40,7 @@ enum { TDM_UT_PIPE_MSG_NONE, + TDM_UT_PIPE_MSG_REPLY, TDM_UT_PIPE_MSG_SERVER_READY, TDM_UT_PIPE_MSG_DPMS_ON, TDM_UT_PIPE_MSG_DPMS_OFF, @@ -47,17 +48,17 @@ enum { }; static int _ut_tdm_pipe_read_msg(int fd); -static bool _ut_tdm_pipe_write_msg(int fd, int msg); +static bool _ut_tdm_pipe_write_msg(int fd, int reply_fd, int msg); static pid_t _ut_tdm_client_server_fork(int *pipe_to_parent, int *pipe_to_child); class TDMClient : public TDMEnv { public: - pid_t server_pid; + static pid_t server_pid; /* 0: read, 1: write */ - int pipe_parent[2]; - int pipe_child[2]; + static int pipe_parent[2]; + static int pipe_child[2]; tdm_client *client; tdm_client_output *output; @@ -66,18 +67,61 @@ public: double vrefresh_interval, start, end; TDMClient(); + void SetUp(void); void TearDown(void); bool PrepareClient(void); bool PrepareOutput(void); bool PrepareVblank(void); + + static void TearDownTestCase(void); + static void ServerFork(void); + static void ServerKill(void); }; -TDMClient::TDMClient() +pid_t TDMClient::server_pid = -1; +int TDMClient::pipe_parent[2] = {-1, -1}; +int TDMClient::pipe_child[2] = {-1, -1}; + +void TDMClient::TearDownTestCase(void) +{ + ServerKill(); +} + +void TDMClient::ServerFork(void) +{ + if (server_pid > 0) + return; + + server_pid = _ut_tdm_client_server_fork(pipe_parent, pipe_child); + ASSERT_TRUE(server_pid > 0); +} + +void TDMClient::ServerKill(void) { + if (pipe_child[0] >= 0) + close(pipe_child[0]); + if (pipe_child[1] >= 0) { + if (server_pid > 0) { + _ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_TERMINATE_SERVER); + waitpid(server_pid, NULL, 0); + TDM_INFO("*** server terminated ***"); + } + close(pipe_child[1]); + } + + if (pipe_parent[0] >= 0) + close(pipe_parent[0]); + if (pipe_parent[1] >= 0) + close(pipe_parent[1]); + server_pid = -1; pipe_parent[0] = pipe_parent[1] = -1; pipe_child[0] = pipe_child[1] = -1; +} + +TDMClient::TDMClient() +{ client = NULL; output = NULL; vblank = NULL; @@ -88,32 +132,19 @@ void TDMClient::SetUp(void) { TDMEnv::SetUp(); - server_pid = _ut_tdm_client_server_fork(pipe_parent, pipe_child); - ASSERT_TRUE(server_pid > 0); + if (server_pid == -1) + ServerFork(); } void TDMClient::TearDown(void) { + ASSERT_TRUE(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON) == true); + if (vblank) tdm_client_vblank_destroy(vblank); if (client) tdm_client_destroy(client); - if (pipe_child[0] >= 0) - close(pipe_child[0]); - if (pipe_child[1] >= 0) { - _ut_tdm_pipe_write_msg(pipe_child[1], TDM_UT_PIPE_MSG_TERMINATE_SERVER); - if (server_pid > 0) - waitpid(server_pid, NULL, 0); - TDM_INFO("*** server terminated ***"); - close(pipe_child[1]); - } - - if (pipe_parent[0] >= 0) - close(pipe_parent[0]); - if (pipe_parent[1] >= 0) - close(pipe_parent[1]); - TDMEnv::TearDown(); } @@ -163,28 +194,30 @@ bool TDMClient::PrepareVblank(void) static int _ut_tdm_pipe_read_msg(int fd) { - char buffer[1024]; ssize_t len; - int *msg; + int msg; do { - len = read(fd, buffer, sizeof buffer); + len = read(fd, &msg, sizeof msg); } while (len < 0 && errno == EINTR); if (len <= 0) - return TDM_UT_PIPE_MSG_NONE; - - msg = (int*)buffer; + msg = TDM_UT_PIPE_MSG_NONE; - return *msg; + return msg; } static bool -_ut_tdm_pipe_write_msg(int fd, int msg) +_ut_tdm_pipe_write_msg(int fd, int reply_fd, int msg) { ssize_t len = write(fd, &msg, sizeof msg); TDM_UT_RETURN_FALSE_IF_FAIL(len == sizeof msg); + if (reply_fd >= 0) { + int reply = _ut_tdm_pipe_read_msg(reply_fd); + TDM_UT_RETURN_FALSE_IF_FAIL(reply == TDM_UT_PIPE_MSG_REPLY); + } + return true; } @@ -235,10 +268,10 @@ _ut_tdm_server_run(int *pipe_parent, int *pipe_child) if (!ut_tdm_output_is_connected(output)) continue; - TDM_UT_GOTO_IF_FAIL(ut_tdm_output_prepare(dpy, output) == true, done); + TDM_UT_GOTO_IF_FAIL(ut_tdm_output_prepare(dpy, output, true) == true, done); } - TDM_UT_GOTO_IF_FAIL(_ut_tdm_pipe_write_msg(pipe_parent[1], TDM_UT_PIPE_MSG_SERVER_READY) == true, done); + TDM_UT_GOTO_IF_FAIL(_ut_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_SERVER_READY) == true, done); TDM_INFO("*** server ready ***"); @@ -268,10 +301,11 @@ _ut_tdm_server_run(int *pipe_parent, int *pipe_child) } if (fds[0].revents & POLLIN) - ret = tdm_display_handle_events(dpy); + ret = ut_tdm_display_handle_events(dpy); if (fds[1].revents & POLLIN) { int msg = _ut_tdm_pipe_read_msg(pipe_child[0]); + _ut_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_REPLY); switch (msg) { case TDM_UT_PIPE_MSG_DPMS_ON: @@ -331,8 +365,6 @@ failed: return -1; } -#ifdef UT_TDM_CLIENT_ENABLE - TEST_P(TDMClient, ClientCreate) { tdm_error ret; @@ -390,17 +422,17 @@ TEST_P(TDMClient, ClientGetFdNullOther) ASSERT_TRUE(tdm_client_get_fd(client, NULL) == TDM_ERROR_INVALID_PARAMETER); } -/* tdm_client_handle_events */ +/* tdm_client_handle_events_timeout */ TEST_P(TDMClient, DISABLED_ClientHandleEvent) { ASSERT_TRUE(PrepareClient() == true); -// ASSERT_TRUE(tdm_client_handle_events(client) == TDM_ERROR_NONE); +// ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); } TEST_P(TDMClient, ClientHandleEventNullObject) { - ASSERT_TRUE(tdm_client_handle_events(NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_TRUE(tdm_client_handle_events_timeout(NULL, 3000) == TDM_ERROR_INVALID_PARAMETER); } static void @@ -422,7 +454,7 @@ TEST_P(TDMClient, ClientWaitVblank) ASSERT_TRUE(done == false); while (!done) - ASSERT_TRUE(tdm_client_handle_events(client) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); } /* tdm_client_get_output */ @@ -515,10 +547,10 @@ TEST_P(TDMClient, ClientOutputAddChangeHandler) ASSERT_TRUE(PrepareOutput() == true); ASSERT_TRUE(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, &done) == TDM_ERROR_NONE); - ASSERT_TRUE(_ut_tdm_pipe_write_msg(pipe_child[1], TDM_UT_PIPE_MSG_DPMS_OFF) == true); + ASSERT_TRUE(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF) == true); while (!done) - ASSERT_TRUE(tdm_client_handle_events(client) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_client_output_get_dpms(output, &dpms) == TDM_ERROR_NONE); ASSERT_TRUE(dpms == TDM_OUTPUT_DPMS_OFF); @@ -573,12 +605,8 @@ _ut_tdm_client_output_change_dpms_cb2(tdm_client_output *output, tdm_value value, void *user_data) { - bool *done = (bool *)user_data; - switch (type) { case TDM_OUTPUT_CHANGE_DPMS: - if (done) - *done = true; tdm_client_output_remove_change_handler(output, _ut_tdm_client_output_change_dpms_cb2, user_data); break; default: @@ -588,36 +616,18 @@ _ut_tdm_client_output_change_dpms_cb2(tdm_client_output *output, TEST_P(TDMClient, ClientOutputRemoveChangeHandlerInHandler) { - bool done; - tdm_output_dpms dpms; + tdm_output_dpms dpms = TDM_OUTPUT_DPMS_ON; ASSERT_TRUE(PrepareClient() == true); ASSERT_TRUE(PrepareOutput() == true); - done = false; - ASSERT_TRUE(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb2, &done) == TDM_ERROR_NONE); - - ASSERT_TRUE(_ut_tdm_pipe_write_msg(pipe_child[1], TDM_UT_PIPE_MSG_DPMS_OFF) == true); - while (!done) - ASSERT_TRUE(tdm_client_handle_events(client) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_client_output_get_dpms(output, &dpms) == TDM_ERROR_NONE); - ASSERT_TRUE(dpms == TDM_OUTPUT_DPMS_OFF); - - done = false; - ASSERT_TRUE(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb2, &done) == TDM_ERROR_NONE); - ASSERT_TRUE(_ut_tdm_pipe_write_msg(pipe_child[1], TDM_UT_PIPE_MSG_DPMS_ON) == true); - while (!done) - ASSERT_TRUE(tdm_client_handle_events(client) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_client_output_get_dpms(output, &dpms) == TDM_ERROR_NONE); - ASSERT_TRUE(dpms == TDM_OUTPUT_DPMS_ON); - - done = false; - ASSERT_TRUE(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb2, &done) == TDM_ERROR_NONE); - ASSERT_TRUE(_ut_tdm_pipe_write_msg(pipe_child[1], TDM_UT_PIPE_MSG_DPMS_OFF) == true); - while (!done) - ASSERT_TRUE(tdm_client_handle_events(client) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb2, NULL) == TDM_ERROR_NONE); + ASSERT_TRUE(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF) == true); ASSERT_TRUE(tdm_client_output_get_dpms(output, &dpms) == TDM_ERROR_NONE); - ASSERT_TRUE(dpms == TDM_OUTPUT_DPMS_OFF); + while (dpms != TDM_OUTPUT_DPMS_OFF) { + ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_client_output_get_dpms(output, &dpms) == TDM_ERROR_NONE); + } } TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullObject) @@ -921,7 +931,7 @@ TEST_P(TDMClient, ClientVblankWait) start = tdm_helper_get_time(); while (!done) - ASSERT_TRUE(tdm_client_handle_events(client) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ @@ -943,7 +953,7 @@ TEST_P(TDMClient, ClientVblankWaitFewTime) start = tdm_helper_get_time(); while(!done1 || !done2 || !done3) - ASSERT_TRUE(tdm_client_handle_events(client) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ @@ -975,7 +985,7 @@ TEST_P(TDMClient, ClientVblankWaitInterval) start = tdm_helper_get_time(); while (!done) - ASSERT_TRUE(tdm_client_handle_events(client) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ @@ -1008,12 +1018,12 @@ TEST_P(TDMClient, ClientVblankWaitSeq) ASSERT_TRUE(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb3, &cur_seq) == TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(tdm_client_handle_events(client) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); start = tdm_helper_get_time(); ASSERT_TRUE(tdm_client_vblank_wait_seq(vblank, cur_seq + 1, _ut_tdm_client_vblank_cb3, &temp) == TDM_ERROR_NONE); while (temp == 0) - ASSERT_TRUE(tdm_client_handle_events(client) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ @@ -1033,19 +1043,14 @@ TEST_P(TDMClient, ClientVblankWaitSeqInterval) ASSERT_TRUE(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb3, &cur_seq) == TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(tdm_client_handle_events(client) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); start = tdm_helper_get_time(); ASSERT_TRUE(tdm_client_vblank_wait_seq(vblank, cur_seq + t, _ut_tdm_client_vblank_cb3, &temp) == TDM_ERROR_NONE); while (temp == 0) - ASSERT_TRUE(tdm_client_handle_events(client) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); end = tdm_helper_get_time(); -#if 0 -printf("@@@ %s(%d) cur_seq(%d) t(%d) start(%.6f) end(%.6f) diff(%.6f) (%.6f~%.6f)\n", -__FUNCTION__, __LINE__, cur_seq, t, start, end, end - start, (interval * (t - 1)), (interval * t + interval)); -#endif - /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ ASSERT_TRUE((end - start) > (vrefresh_interval * (t - 1))); ASSERT_TRUE((end - start) < (vrefresh_interval * t + vrefresh_interval)); @@ -1076,7 +1081,7 @@ TEST_P(TDMClient, ClientVblankWaitDpmsOff) ASSERT_TRUE(PrepareOutput() == true); ASSERT_TRUE(PrepareVblank() == true); - ASSERT_TRUE(_ut_tdm_pipe_write_msg(pipe_child[1], TDM_UT_PIPE_MSG_DPMS_OFF) == true); + ASSERT_TRUE(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF) == true); while (dpms != TDM_OUTPUT_DPMS_OFF) ASSERT_TRUE(tdm_client_output_get_dpms(output, &dpms) == TDM_ERROR_NONE); ASSERT_TRUE(dpms == TDM_OUTPUT_DPMS_OFF); @@ -1093,7 +1098,7 @@ TEST_P(TDMClient, ClientVblankWaitSetEnableFakeDpmsOff) ASSERT_TRUE(PrepareOutput() == true); ASSERT_TRUE(PrepareVblank() == true); - ASSERT_TRUE(_ut_tdm_pipe_write_msg(pipe_child[1], TDM_UT_PIPE_MSG_DPMS_OFF) == true); + ASSERT_TRUE(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF) == true); while (dpms != TDM_OUTPUT_DPMS_OFF) ASSERT_TRUE(tdm_client_output_get_dpms(output, &dpms) == TDM_ERROR_NONE); @@ -1103,7 +1108,7 @@ TEST_P(TDMClient, ClientVblankWaitSetEnableFakeDpmsOff) ASSERT_TRUE(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done) == TDM_ERROR_NONE); while (!done) - ASSERT_TRUE(tdm_client_handle_events(client) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankWaitSetOffset) @@ -1121,7 +1126,7 @@ TEST_P(TDMClient, ClientVblankWaitSetOffset) start = tdm_helper_get_time(); while (!done) - ASSERT_TRUE(tdm_client_handle_events(client) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ @@ -1147,7 +1152,7 @@ TEST_P(TDMClient, ClientVblankWaitSetFps) start = tdm_helper_get_time(); while (!done) - ASSERT_TRUE(tdm_client_handle_events(client) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ @@ -1189,7 +1194,7 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps) start = tdm_helper_get_time(); while (cur_seq[0] == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); end = tdm_helper_get_time(); ASSERT_TRUE(cur_seq[1] != 0); @@ -1208,12 +1213,12 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps) } while (cur_seq[0] == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); ASSERT_TRUE(cur_seq[1] == 0); ASSERT_TRUE(cur_seq[2] == 0); while (cur_seq[1] == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); ASSERT_TRUE(cur_seq[2] == 0); } @@ -1246,7 +1251,7 @@ TEST_P(TDMVblank, VblankWaitIgnoreGlobalFps) start = tdm_helper_get_time(); while (cur_seq[1] == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); end = tdm_helper_get_time(); ASSERT_TRUE(cur_seq[0] == 0); @@ -1256,14 +1261,18 @@ TEST_P(TDMVblank, VblankWaitIgnoreGlobalFps) ASSERT_TRUE((end - start) < (interval + interval)); while (cur_seq[0] == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); ASSERT_TRUE(cur_seq[2] != 0); } #endif +#ifdef TDM_UT_TEST_WITH_PARAMS INSTANTIATE_TEST_CASE_P(TDMClientParams, TDMClient, Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE))); - +#else +INSTANTIATE_TEST_CASE_P(TDMClientParams, + TDMClient, + Values(TDM_DEFAULT_MODULE)); #endif diff --git a/utests/src/ut_tdm_display.cpp b/utests/src/ut_tdm_display.cpp index 054786b..c1d5043 100644 --- a/utests/src/ut_tdm_display.cpp +++ b/utests/src/ut_tdm_display.cpp @@ -71,7 +71,48 @@ void TDMDisplay::TearDown(void) TDMEnv::TearDown(); } -#ifdef UT_TDM_DISPLAY_ENABLE +tdm_error +ut_tdm_display_handle_events(tdm_display *dpy) +{ + struct pollfd fds; + int fd = -1; + tdm_error ret; + int result; + + ret = tdm_display_get_fd(dpy, &fd); + TDM_UT_RETURN_VAL_IF_FAIL(fd >= 0, ret); + + fds.events = POLLIN; + fds.fd = fd; + fds.revents = 0; + + do { + result = poll(&fds, 1, 3000); + } while (result == -1 && errno == EINTR); + + if (result == 0) { + TDM_UT_ERR("polling tdm_fd timeout."); + return TDM_ERROR_TIMEOUT; + } + + return tdm_display_handle_events(dpy); +} + +bool +ut_tdm_display_has_pp_capability(tdm_display *dpy) +{ + tdm_display_capability capabilities = (tdm_display_capability)0; + TDM_UT_RETURN_FALSE_IF_FAIL(tdm_display_get_capabilities(dpy, &capabilities) == TDM_ERROR_NONE); + return capabilities & TDM_DISPLAY_CAPABILITY_PP; +} + +bool +ut_tdm_display_has_capture_capability(tdm_display *dpy) +{ + tdm_display_capability capabilities = (tdm_display_capability)0; + TDM_UT_RETURN_FALSE_IF_FAIL(tdm_display_get_capabilities(dpy, &capabilities) == TDM_ERROR_NONE); + return capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE; +} TEST_P(TDMDisplay, DisplayUpdate) { @@ -124,7 +165,7 @@ TEST_P(TDMDisplay, DisplayGetFDWrongDpy) TEST_P(TDMDisplay, DISABLED_DisplayHandleEvents) { /* TODO Generate events*/ - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); } TEST_P(TDMDisplay, DisplayFlush) @@ -373,7 +414,7 @@ TEST_P(TDMDisplay, DisplayCreatePpNullObject) ASSERT_TRUE(pp == NULL); } -TEST_P(TDMDisplay, BackendGetInfo) +TEST_P(TDMDisplay, ModuleGetInfo) { tdm_output *output; int o, count = TDM_UT_INVALID_VALUE; @@ -405,7 +446,7 @@ TEST_P(TDMDisplay, BackendGetInfo) } } -TEST_P(TDMDisplay, BackendGetInfoNullObject) +TEST_P(TDMDisplay, ModuleGetInfoNullObject) { const char *name = (const char *)TDM_UT_INVALID_VALUE; const char *vendor = (const char *)TDM_UT_INVALID_VALUE; @@ -419,7 +460,7 @@ TEST_P(TDMDisplay, BackendGetInfoNullObject) ASSERT_TRUE(minor == TDM_UT_INVALID_VALUE); } -TEST_P(TDMDisplay, BackendGetInfoNullOther) +TEST_P(TDMDisplay, ModuleGetInfoNullOther) { tdm_output *output; int o, count = TDM_UT_INVALID_VALUE; @@ -443,8 +484,12 @@ TEST_P(TDMDisplay, BackendGetInfoNullOther) } } +#ifdef TDM_UT_TEST_WITH_PARAMS INSTANTIATE_TEST_CASE_P(TDMDisplayParams, TDMDisplay, Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE))); - -#endif +#else +INSTANTIATE_TEST_CASE_P(TDMDisplayParams, + TDMDisplay, + Values(TDM_DEFAULT_MODULE)); +#endif \ No newline at end of file diff --git a/utests/src/ut_tdm_env.cpp b/utests/src/ut_tdm_env.cpp index f94b77d..d717423 100644 --- a/utests/src/ut_tdm_env.cpp +++ b/utests/src/ut_tdm_env.cpp @@ -33,23 +33,35 @@ void TDMEnv::SetUp(void) { const char *test_backend; + int thread = 1; TDM_UT_ENTRY(); setenv("XDG_RUNTIME_DIR", "/run", 1); setenv("TBM_DISPLAY_SERVER", "1", 1); - tdm_config_set_int(TDM_CONFIG_KEY_GENERAL_THREAD, ::testing::get<0>(GetParam())); - tdm_config_set_int(TDM_CONFIG_KEY_GENERAL_COMMIT_PER_VBLANK, ::testing::get<1>(GetParam())); - - const char *debug = getenv("TDM_DEBUG_MODULE"); - if (debug && strstr(debug, "1")) - tdm_config_set_string(TDM_CONFIG_KEY_DEBUG_MODULE, "buffer,thread,event,vblank,commit,pp,capture"); +#ifdef TDM_UT_TEST_WITH_PARAMS + /* commit_per_vblank depends on backend. can't choose it in frontend side. + * this is only for testing. + */ + int commit_per_vblank = ::testing::get<0>(GetParam()); + tdm_config_set_int(TDM_CONFIG_KEY_GENERAL_COMMIT_PER_VBLANK, commit_per_vblank); + thread = ::testing::get<1>(GetParam()); test_backend = ::testing::get<2>(GetParam()); +#else + test_backend = ::testing::get<0>(GetParam()); +#endif + + tdm_config_set_int(TDM_CONFIG_KEY_GENERAL_THREAD, thread); + if (!test_backend) test_backend = TDM_DEFAULT_MODULE; tdm_config_set_string(TDM_CONFIG_KEY_GENERAL_BACKENDS, test_backend); + + const char *debug = getenv("TDM_UT_DEBUG_MODULE"); + if (debug && strstr(debug, "1")) + tdm_config_set_string(TDM_CONFIG_KEY_DEBUG_MODULE, "buffer,thread,event,vblank,commit,pp,capture"); } void TDMEnv::TearDown(void) @@ -58,8 +70,6 @@ void TDMEnv::TearDown(void) unsetenv("TBM_DISPLAY_SERVER"); } -#ifdef UT_TDM_ENV_ENABLE - TEST_P(TDMEnv, DisplayInitDeinit) { tdm_display *dpy; @@ -166,8 +176,12 @@ TEST_P(TDMEnv, DisplayDeinitRepeatWithSameDpy) tdm_display_deinit(dpy); } +#ifdef TDM_UT_TEST_WITH_PARAMS INSTANTIATE_TEST_CASE_P(TDMEnvParams, TDMEnv, Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE))); - +#else +INSTANTIATE_TEST_CASE_P(TDMEnvParams, + TDMEnv, + Values(TDM_DEFAULT_MODULE)); #endif diff --git a/utests/src/ut_tdm_event_loop.cpp b/utests/src/ut_tdm_event_loop.cpp index 58641db..0b5f930 100644 --- a/utests/src/ut_tdm_event_loop.cpp +++ b/utests/src/ut_tdm_event_loop.cpp @@ -53,8 +53,6 @@ void TDMEventLoop::TearDown(void) TDMDisplay::TearDown(); } -#ifdef UT_TDM_EVENT_LOOP_ENABLE - static tdm_error _ut_tdm_event_loop_fd_cb(int fd, tdm_event_loop_mask mask, void *user_data) { @@ -85,7 +83,7 @@ TEST_P(TDMEventLoop, EventLoopAddFdHandler) //TODO // while (!done) -// ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); +// ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); tdm_event_loop_source_remove(source); @@ -135,7 +133,7 @@ TEST_P(TDMEventLoop, EventLoopSourceFdUpdate) //TODO // while (!done) -// ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); +// ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); tdm_event_loop_source_remove(source); @@ -196,7 +194,7 @@ TEST_P(TDMEventLoop, EventLoopSourceTimerUpdate) ASSERT_TRUE(tdm_event_loop_source_timer_update(source, 100) == TDM_ERROR_NONE); //TODO // while (!done) -// ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); +// ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); tdm_event_loop_source_remove(source); } @@ -210,8 +208,12 @@ TEST_P(TDMEventLoop, EventLoopSourceRemoveNullObject) tdm_event_loop_source_remove(NULL); } +#ifdef TDM_UT_TEST_WITH_PARAMS INSTANTIATE_TEST_CASE_P(TDMEventLoopParams, TDMEventLoop, Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE))); - +#else +INSTANTIATE_TEST_CASE_P(TDMEventLoopParams, + TDMEventLoop, + Values(TDM_DEFAULT_MODULE)); #endif diff --git a/utests/src/ut_tdm_helper.cpp b/utests/src/ut_tdm_helper.cpp index 7f2f2e0..ddb4e44 100644 --- a/utests/src/ut_tdm_helper.cpp +++ b/utests/src/ut_tdm_helper.cpp @@ -51,8 +51,6 @@ void TDMHelper::TearDown(void) TDMOutput::TearDown(); } -#ifdef UT_TDM_HELPER_ENABLE - TEST_P(TDMHelper, HelperGetTime) { ASSERT_TRUE(tdm_helper_get_time() > 0.0); @@ -458,7 +456,7 @@ TEST_P(TDMHelper, HelperCaptureOutput) if (!ut_tdm_output_is_connected(output)) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, output) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, output, true) == true); dump = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888); ASSERT_TRUE(dump != NULL); @@ -511,7 +509,7 @@ TEST_P(TDMHelper, HelperGetDisplayInformation) ASSERT_TRUE(output != NULL); if (!ut_tdm_output_is_connected(output)) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, output) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, output, true) == true); } tdm_helper_get_display_information(dpy, reply, &len); @@ -557,8 +555,12 @@ TEST_P(TDMHelper, HelperOutputCommitPerVblankEnabledNullObject) tdm_helper_output_commit_per_vblank_enabled(NULL); } +#ifdef TDM_UT_TEST_WITH_PARAMS INSTANTIATE_TEST_CASE_P(TDMHelperParams, TDMHelper, Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE))); - +#else +INSTANTIATE_TEST_CASE_P(TDMHelperParams, + TDMHelper, + Values(TDM_DEFAULT_MODULE)); #endif diff --git a/utests/src/ut_tdm_hwc_window.cpp b/utests/src/ut_tdm_hwc_window.cpp index d18a161..2a1fdf5 100644 --- a/utests/src/ut_tdm_hwc_window.cpp +++ b/utests/src/ut_tdm_hwc_window.cpp @@ -84,8 +84,6 @@ void TDMHwcWindow::TearDown(void) TDMOutput::TearDown(); } -#ifdef UT_TDM_HWC_WINDOW_ENABLE - /* tdm_error tdm_output_hwc_destroy_window(tdm_output *output, tdm_hwc_window *hwc_window); */ TEST_P(TDMHwcWindow, DestroyWindowFailNull) { @@ -459,7 +457,12 @@ TEST_P(TDMHwcWindow, SetPropertyFailWrongId) ASSERT_NE(TDM_ERROR_NONE, error); } +#ifdef TDM_UT_TEST_WITH_PARAMS INSTANTIATE_TEST_CASE_P(TDMHwcWindowParams, TDMHwcWindow, Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE))); -#endif +#else +INSTANTIATE_TEST_CASE_P(TDMHwcWindowParams, + TDMHwcWindow, + Values(TDM_DEFAULT_MODULE)); +#endif \ No newline at end of file diff --git a/utests/src/ut_tdm_layer.cpp b/utests/src/ut_tdm_layer.cpp index 5b8042a..2a37e0e 100644 --- a/utests/src/ut_tdm_layer.cpp +++ b/utests/src/ut_tdm_layer.cpp @@ -92,6 +92,10 @@ void TDMLayer::SetUp(void) void TDMLayer::TearDown(void) { + for (int l = 0; l < layer_count; l++) { + ASSERT_TRUE(tdm_layer_unset_buffer(layers[l]) == TDM_ERROR_NONE); + } + free(layers); DestroyBuffers(); @@ -141,6 +145,24 @@ ut_tdm_layer_is_video_layer(tdm_layer *layer) return capabilities & TDM_LAYER_CAPABILITY_VIDEO; } +bool +ut_tdm_layer_support_scale(tdm_layer *layer) +{ + tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE; + if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE) + return false; + return capabilities & TDM_LAYER_CAPABILITY_SCALE; +} + +bool +ut_tdm_layer_support_no_crop(tdm_layer *layer) +{ + tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE; + if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE) + return false; + return capabilities & TDM_LAYER_CAPABILITY_NO_CROP; +} + unsigned int ut_tdm_layer_get_output_pipe(tdm_layer *layer) { @@ -182,12 +204,14 @@ ut_tdm_layer_find_best_format(tdm_layer *layer) } bool -ut_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer_count) +ut_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer_count, bool fill) { tdm_error ret; unsigned int flags = 0; tbm_format format = (tbm_format)0; int w, h; + tdm_output *output; + const tdm_output_mode *mode = NULL; /* create buffers */ TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE); @@ -195,25 +219,22 @@ ut_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer format = ut_tdm_layer_find_best_format(layer); TDM_UT_RETURN_FALSE_IF_FAIL(format != 0); - if (ut_tdm_layer_is_primary_layer(layer)) { - tdm_output *output; - const tdm_output_mode *mode = NULL; - - output = tdm_layer_get_output(layer, &ret); - TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE); - TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL); + output = tdm_layer_get_output(layer, &ret); + TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE); + TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL); - TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE); - TDM_UT_RETURN_FALSE_IF_FAIL(mode != NULL); + TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE); + TDM_UT_RETURN_FALSE_IF_FAIL(mode != NULL); + if (ut_tdm_layer_is_primary_layer(layer)) { w = mode->hdisplay; h = mode->vdisplay; } else { - w = TDM_UT_BUFFER_SIZE; - h = TDM_UT_BUFFER_SIZE; + w = mode->hdisplay / 2; + h = mode->vdisplay / 2; } - TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_buffer_create(w, h, format, flags | TBM_BO_SCANOUT, true, buffer_count, buffers) == true); + TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_buffer_create(w, h, format, flags | TBM_BO_SCANOUT, fill, buffer_count, buffers) == true); TDM_INFO("preparing buffers done"); @@ -283,9 +304,9 @@ ut_tdm_layer_fill_info(tdm_layer *layer, int w, int h, tbm_format format, tdm_in TDM_UT_RETURN_FALSE_IF_FAIL(zpos >= 0); if (w == -1 || h == -1 || format == 0) { - w = TDM_UT_BUFFER_SIZE; - h = TDM_UT_BUFFER_SIZE; - format = TBM_FORMAT_ARGB8888; + w = mode->hdisplay; + h = mode->vdisplay; + format = ut_tdm_layer_find_best_format(layer); } /* TODO: check min,max,prefered size and avaiable formats */ @@ -301,8 +322,8 @@ ut_tdm_layer_fill_info(tdm_layer *layer, int w, int h, tbm_format format, tdm_in info->dst_pos.x = 0; info->dst_pos.y = 0; } else { - info->dst_pos.x = (mode->hdisplay - w) / count * zpos; - info->dst_pos.y = (mode->vdisplay - h) / count * zpos; + info->dst_pos.x = ((mode->hdisplay - w) / count) * (zpos + 1); + info->dst_pos.y = ((mode->vdisplay - h) / count) * (zpos + 1); } info->dst_pos.w = w; info->dst_pos.h = h; @@ -312,7 +333,7 @@ ut_tdm_layer_fill_info(tdm_layer *layer, int w, int h, tbm_format format, tdm_in TDM_INFO("filling output(%d) layer(%d) info done: src_config(%dx%d: %d,%d %dx%d: %c%c%c%c) dst_pos(%d,%d %dx%d) transform(%s)", pipe, zpos, - info->src_config.size.h, info->src_config.size.h, + info->src_config.size.h, info->src_config.size.v, info->src_config.pos.x, info->src_config.pos.y, info->src_config.pos.w, info->src_config.pos.h, FOURCC_STR(info->src_config.format), info->dst_pos.x, info->dst_pos.y, info->dst_pos.w, info->dst_pos.h, @@ -321,7 +342,37 @@ ut_tdm_layer_fill_info(tdm_layer *layer, int w, int h, tbm_format format, tdm_in return true; } -#ifdef UT_TDM_LAYER_ENABLE +bool ut_tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer) +{ + tdm_info_layer old_info, info; + + TDM_UT_RETURN_FALSE_IF_FAIL(buffer != NULL); + + int bw = tbm_surface_get_width(buffer); + int bh = tbm_surface_get_height(buffer); + tbm_format bf = tbm_surface_get_format(buffer); + + TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_info(layer, &old_info) == TDM_ERROR_NONE); + TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_layer_fill_info(layer, bw, bh, bf, &info) == true); + + if (memcmp(&old_info, &info, sizeof info)) + TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE); + + TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_buffer(layer, buffer) == TDM_ERROR_NONE); + + return true; +} + +bool ut_tdm_layer_is_avaiable(tdm_layer *layer) +{ + tdm_error ret; + tdm_output *output = tdm_layer_get_output(layer, &ret); + TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE); + TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL); + + /* only check if connected */ + return ut_tdm_output_is_connected(output); +} TEST_P(TDMLayer, LayerGetOutput) { @@ -386,6 +437,8 @@ TEST_P(TDMLayer, LayerGetAvailableFormats) TDM_UT_SKIP_FLAG(has_layers); for (int l = 0; l < layer_count; l++) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; ASSERT_TRUE(tdm_layer_get_available_formats(layers[l], &formats, &count) == TDM_ERROR_NONE); @@ -408,7 +461,8 @@ TEST_P(TDMLayer, LayerGetAvailableFormatsNullObject) TEST_P(TDMLayer, LayerGetAvailableFormatsNullOther) { TDM_UT_SKIP_FLAG(has_layers); - + if (!ut_tdm_layer_is_avaiable(layers[0])) + return; ASSERT_TRUE(tdm_layer_get_available_formats(layers[0], NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); } @@ -417,6 +471,8 @@ TEST_P(TDMLayer, LayerGetAvailableProperties) TDM_UT_SKIP_FLAG(has_layers); for (int l = 0; l < layer_count; l++) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; ASSERT_TRUE(tdm_layer_get_available_properties(layers[l], &props, &count) == TDM_ERROR_NONE); @@ -452,6 +508,8 @@ TEST_P(TDMLayer, LayerGetZpos) ASSERT_TRUE(check_table != NULL); for (int l = 0; l < layer_count; l++) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; unsigned int pipe = ut_tdm_layer_get_output_pipe(layers[l]); int zpos = TDM_UT_INVALID_VALUE; EXPECT_TRUE(tdm_layer_get_zpos(layers[l], &zpos) == TDM_ERROR_NONE); @@ -488,6 +546,9 @@ TEST_P(TDMLayer, LayerSetProperty) TDM_UT_SKIP_FLAG(has_layers); for (int l = 0; l < layer_count; l++) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; tdm_value value = {.s32 = 0}; @@ -512,6 +573,9 @@ TEST_P(TDMLayer, LayerGetProperty) TDM_UT_SKIP_FLAG(has_layers); for (int l = 0; l < layer_count; l++) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; ASSERT_TRUE(tdm_layer_get_available_properties(layers[l], &props, &count) == TDM_ERROR_NONE); @@ -544,25 +608,16 @@ TEST_P(TDMLayer, LayerGetPropertyNullOther) ASSERT_TRUE(tdm_layer_get_property(layers[0], 0, NULL) == TDM_ERROR_INVALID_PARAMETER); } -static bool -_ut_tdm_layer_mode_setting_all_output(tdm_display *dpy, tdm_output **outputs, int output_count) -{ - for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_mode_setting(outputs[o])) - return false; - if (tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) != TDM_ERROR_NONE) - return false; - } - return true; -} - TEST_P(TDMLayer, LayerSetInfo) { TDM_UT_SKIP_FLAG(has_layers); - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); + ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + tdm_info_layer info; ASSERT_TRUE(ut_tdm_layer_fill_info(layers[l], -1, -1, 0, &info) == true); ASSERT_TRUE(tdm_layer_set_info(layers[l], &info) == TDM_ERROR_NONE); @@ -585,35 +640,8 @@ TEST_P(TDMLayer, LayerSetInfoNullOther) ASSERT_TRUE(tdm_layer_set_info(layers[0], NULL) == TDM_ERROR_INVALID_PARAMETER); } -TEST_P(TDMLayer, LayerGetInfo) -{ - TDM_UT_SKIP_FLAG(has_layers); - - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); - - for (int l = 0; l < layer_count; l++) { - tdm_info_layer info, temp; - ASSERT_TRUE(ut_tdm_layer_fill_info(layers[l], -1, -1, 0, &info) == true); - ASSERT_TRUE(tdm_layer_set_info(layers[l], &info) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_commit(layers[l], NULL, NULL) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_get_info(layers[l], &temp) == TDM_ERROR_NONE); - ASSERT_TRUE(memcmp(&info, &temp, sizeof info) == 0); - } -} - -TEST_P(TDMLayer, LayerGetInfoNoCommit) +TEST_P(TDMLayer, DISABLED_LayerGetInfo) { - TDM_UT_SKIP_FLAG(has_layers); - - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); - - for (int l = 0; l < layer_count; l++) { - tdm_info_layer info, temp; - ASSERT_TRUE(ut_tdm_layer_fill_info(layers[l], -1, -1, 0, &info) == true); - ASSERT_TRUE(tdm_layer_set_info(layers[l], &info) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_get_info(layers[l], &temp) == TDM_ERROR_NONE); - ASSERT_TRUE(memcmp(&info, &temp, sizeof info) != 0); - } } TEST_P(TDMLayer, LayerGetInfoNullObject) @@ -637,6 +665,9 @@ TEST_P(TDMLayer, LayerGetBufferFlags) TDM_UT_SKIP_FLAG(has_layers); for (int l = 0; l < layer_count; l++) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + unsigned int flags = (unsigned int)TDM_UT_INVALID_VALUE; ASSERT_TRUE(tdm_layer_get_buffer_flags(layers[l], &flags) == TDM_ERROR_NONE); ASSERT_TRUE(flags != (unsigned int)TDM_UT_INVALID_VALUE); @@ -675,20 +706,21 @@ TEST_P(TDMLayer, LayerSetBuffer) tdm_error ret; - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); + ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { - unsigned int usable; + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + tdm_info_layer info; int next_buffer = 0; - bool done; if (ut_tdm_layer_is_cursor_layer(layers[l])) continue; if (ut_tdm_layer_is_video_layer(layers[l])) continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3) == true); + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true) == true); /* set info */ int bw = tbm_surface_get_width(buffers[0]); @@ -696,34 +728,23 @@ TEST_P(TDMLayer, LayerSetBuffer) tbm_format bf = tbm_surface_get_format(buffers[0]); ASSERT_TRUE(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info) == true); - ASSERT_TRUE(tdm_layer_is_usable(layers[l], &usable) == TDM_ERROR_NONE); - ASSERT_TRUE(usable == 1); ASSERT_TRUE(tdm_layer_set_info(layers[l], &info) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_is_usable(layers[l], &usable) == TDM_ERROR_NONE); - ASSERT_TRUE(usable == 0); /* set buffer & commit for 100 times */ - for (int t = 0; t < 100; t++) { - tbm_surface_h displaying_buffer; + for (int t = 0; t < 10; t++) { + tbm_surface_h displaying_buffer = NULL; ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer]) == TDM_ERROR_NONE); - done = false; - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done) == TDM_ERROR_NONE); - while (!done) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); - displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(displaying_buffer == buffers[next_buffer]); + ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL) == TDM_ERROR_NONE); + while (displaying_buffer != buffers[next_buffer]) { + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + } next_buffer++; if (next_buffer == 3) next_buffer = 0; } - ASSERT_TRUE(tdm_layer_is_usable(layers[l], &usable) == TDM_ERROR_NONE); - ASSERT_TRUE(usable == 0); - ASSERT_TRUE(tdm_layer_unset_buffer(layers[l]) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_is_usable(layers[l], &usable) == TDM_ERROR_NONE); - ASSERT_TRUE(usable == 1); - DestroyBuffers(); } } @@ -734,19 +755,21 @@ TEST_P(TDMLayer, LayerSetBufferFewTimeInOneCommit) tdm_error ret; - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); + ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + tdm_info_layer info; int next_buffer = 0; - bool done; if (ut_tdm_layer_is_cursor_layer(layers[l])) continue; if (ut_tdm_layer_is_video_layer(layers[l])) continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3) == true); + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true) == true); /* set info */ int bw = tbm_surface_get_width(buffers[0]); @@ -757,26 +780,22 @@ TEST_P(TDMLayer, LayerSetBufferFewTimeInOneCommit) /* set buffer & commit for 10 times */ for (int t = 0; t < 10; t++) { - tbm_surface_h displaying_buffer; + tbm_surface_h displaying_buffer = NULL; ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]) == TDM_ERROR_NONE); if (next_buffer == 3) next_buffer = 0; ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer]) == TDM_ERROR_NONE); - done = false; - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done) == TDM_ERROR_NONE); - while (!done) { - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL) == TDM_ERROR_NONE); + while (displaying_buffer != buffers[next_buffer]) { + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); } - displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(displaying_buffer == buffers[next_buffer]); next_buffer++; if (next_buffer == 3) next_buffer = 0; } - ASSERT_TRUE(tdm_layer_unset_buffer(layers[l]) == TDM_ERROR_NONE); - DestroyBuffers(); } } @@ -800,10 +819,14 @@ TEST_P(TDMLayer, LayerUnsetBuffer) { TDM_UT_SKIP_FLAG(has_layers); - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); + ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); + + for (int l = 0; l < layer_count; l++) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; - for (int l = 0; l < layer_count; l++) ASSERT_TRUE(tdm_layer_unset_buffer(layers[l]) == TDM_ERROR_NONE); + } } TEST_P(TDMLayer, LayerUnsetBufferNullObject) @@ -817,9 +840,12 @@ TEST_P(TDMLayer, LayerUnsetBufferBeforeCommit) { TDM_UT_SKIP_FLAG(has_layers); - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); + ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + tdm_info_layer info; int next_buffer = 0; @@ -827,8 +853,10 @@ TEST_P(TDMLayer, LayerUnsetBufferBeforeCommit) continue; if (ut_tdm_layer_is_video_layer(layers[l])) continue; + if (ut_tdm_layer_is_primary_layer(layers[l])) + continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3) == true); + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true) == true); /* set info */ int bw = tbm_surface_get_width(buffers[0]); @@ -857,9 +885,12 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommit) { TDM_UT_SKIP_FLAG(has_layers); - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); + ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + tdm_info_layer info; int next_buffer = 0; @@ -867,8 +898,10 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommit) continue; if (ut_tdm_layer_is_video_layer(layers[l])) continue; + if (ut_tdm_layer_is_primary_layer(layers[l])) + continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3) == true); + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true) == true); /* set info */ int bw = tbm_surface_get_width(buffers[0]); @@ -887,13 +920,17 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommit) } } -TEST_P(TDMLayer, LayerUnsetBufferAfterTwoCommit) +/* drmModePageFlip can't be done twice in a vblank */ +TEST_P(TDMLayer, DISABLED_LayerUnsetBufferAfterTwoCommit) { TDM_UT_SKIP_FLAG(has_layers); - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); + ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + tdm_info_layer info; int next_buffer = 0; @@ -901,8 +938,10 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterTwoCommit) continue; if (ut_tdm_layer_is_video_layer(layers[l])) continue; + if (ut_tdm_layer_is_primary_layer(layers[l])) + continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3) == true); + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true) == true); /* set info */ int bw = tbm_surface_get_width(buffers[0]); @@ -923,13 +962,17 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterTwoCommit) } } -TEST_P(TDMLayer, LayerUnsetBufferAfterTwoCommitOneSetBuffer) +/* drmModePageFlip can't be done twice in a vblank */ +TEST_P(TDMLayer, DISABLED_LayerUnsetBufferAfterTwoCommitOneSetBuffer) { TDM_UT_SKIP_FLAG(has_layers); - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); + ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + tdm_info_layer info; int next_buffer = 0; @@ -937,8 +980,10 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterTwoCommitOneSetBuffer) continue; if (ut_tdm_layer_is_video_layer(layers[l])) continue; + if (ut_tdm_layer_is_primary_layer(layers[l])) + continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3) == true); + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true) == true); /* set info */ int bw = tbm_surface_get_width(buffers[0]); @@ -965,9 +1010,12 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDone) { TDM_UT_SKIP_FLAG(has_layers); - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); + ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + tdm_info_layer info; int next_buffer = 0; bool done; @@ -976,8 +1024,10 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDone) continue; if (ut_tdm_layer_is_video_layer(layers[l])) continue; + if (ut_tdm_layer_is_primary_layer(layers[l])) + continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3) == true); + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true) == true); /* set info */ int bw = tbm_surface_get_width(buffers[0]); @@ -993,7 +1043,7 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDone) done = false; ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done) == TDM_ERROR_NONE); while (!done) { - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); } ASSERT_TRUE(tdm_layer_unset_buffer(layers[l]) == TDM_ERROR_NONE); @@ -1006,9 +1056,12 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDoneOneCommit) { TDM_UT_SKIP_FLAG(has_layers); - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); + ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + tdm_info_layer info; int next_buffer = 0; bool done; @@ -1017,8 +1070,10 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDoneOneCommit) continue; if (ut_tdm_layer_is_video_layer(layers[l])) continue; + if (ut_tdm_layer_is_primary_layer(layers[l])) + continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3) == true); + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true) == true); /* set info */ int bw = tbm_surface_get_width(buffers[0]); @@ -1034,7 +1089,7 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDoneOneCommit) done = false; ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done) == TDM_ERROR_NONE); while (!done) { - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); } ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]) == TDM_ERROR_NONE); @@ -1047,37 +1102,25 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDoneOneCommit) } } -TEST_P(TDMLayer, LayerCommit) +TEST_P(TDMLayer, LayerCommitDPMSOff) { TDM_UT_SKIP_FLAG(has_layers); - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); + tdm_error ret; + tdm_output *output = tdm_layer_get_output(layers[0], &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_TRUE(output != NULL); - for (int l = 0; l < layer_count; l++) { - if (ut_tdm_layer_is_cursor_layer(layers[l])) - continue; - if (ut_tdm_layer_is_video_layer(layers[l])) - continue; + if (!ut_tdm_output_is_connected(output)) + return; - for (int t = 0; t < 10; t++) { - unsigned int committing; - bool done = false; - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_is_committing(layers[l], &committing) == TDM_ERROR_NONE); - ASSERT_TRUE(committing == 1); - while (!done) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_is_committing(layers[l], &committing) == TDM_ERROR_NONE); - ASSERT_TRUE(committing == 0); - } - } -} + EXPECT_TRUE(ut_tdm_output_prepare(dpy, output, true) == true); -TEST_P(TDMLayer, LayerCommitDPMSOff) -{ - TDM_UT_SKIP_FLAG(has_layers); + EXPECT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + + EXPECT_TRUE(tdm_layer_commit(layers[0], NULL, NULL) == TDM_ERROR_DPMS_OFF); - ASSERT_TRUE(tdm_layer_commit(layers[0], NULL, NULL) == TDM_ERROR_DPMS_OFF); + EXPECT_TRUE(ut_tdm_output_unset(dpy, output) == true); } TEST_P(TDMLayer, LayerCommitNullObject) @@ -1091,44 +1134,11 @@ TEST_P(TDMLayer, LayerCommitNullOther) { TDM_UT_SKIP_FLAG(has_layers); - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); + ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); ASSERT_TRUE(tdm_layer_commit(layers[0], NULL, NULL) == TDM_ERROR_NONE); } -TEST_P(TDMLayer, LayerCommitFewTimesInOneVblank) -{ - TDM_UT_SKIP_FLAG(has_layers); - - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); - - for (int l = 0; l < layer_count; l++) { - tdm_error ret; - tdm_output *output = tdm_layer_get_output(layers[l], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); - - if (ut_tdm_layer_is_cursor_layer(layers[l])) - continue; - if (ut_tdm_layer_is_video_layer(layers[l])) - continue; - - for (int t = 0; t < 10; t++) { - unsigned int committing; - bool done1 = false, done2 = false, done3 = false; - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_is_committing(layers[l], &committing) == TDM_ERROR_NONE); - ASSERT_TRUE(committing == 1); - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done2) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done3) == TDM_ERROR_NONE); - while (!done1 || !done2 || !done3) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_is_committing(layers[l], &committing) == TDM_ERROR_NONE); - ASSERT_TRUE(committing == 0); - } - } -} - TEST_P(TDMLayer, LayerIsCommittingNullObject) { TDM_UT_SKIP_FLAG(has_layers); @@ -1149,9 +1159,12 @@ TEST_P(TDMLayer, LayerRemoveCommitHandler) { TDM_UT_SKIP_FLAG(has_layers); - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); + ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + tdm_error ret; tdm_output *output = tdm_layer_get_output(layers[l], &ret); ASSERT_TRUE(ret == TDM_ERROR_NONE); @@ -1161,6 +1174,19 @@ TEST_P(TDMLayer, LayerRemoveCommitHandler) continue; if (ut_tdm_layer_is_video_layer(layers[l])) continue; + if (ut_tdm_layer_is_primary_layer(layers[l])) + continue; + + ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 1, true) == true); + + /* set info */ + tdm_info_layer info; + int bw = tbm_surface_get_width(buffers[0]); + int bh = tbm_surface_get_height(buffers[0]); + tbm_format bf = tbm_surface_get_format(buffers[0]); + ASSERT_TRUE(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info) == true); + ASSERT_TRUE(tdm_layer_set_info(layers[l], &info) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[0]) == TDM_ERROR_NONE); for (int t = 0; t < 10; t++) { bool done1 = false, done2 = false, done3 = false; @@ -1169,9 +1195,11 @@ TEST_P(TDMLayer, LayerRemoveCommitHandler) ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done3) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_layer_remove_commit_handler(layers[l], _ut_tdm_layer_commit_cb, &done2) == TDM_ERROR_NONE); while (!done1 || done2 || !done3) { - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); } } + + DestroyBuffers(); } } @@ -1179,9 +1207,12 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerDifferentData) { TDM_UT_SKIP_FLAG(has_layers); - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); + ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + tdm_error ret; tdm_output *output = tdm_layer_get_output(layers[l], &ret); ASSERT_TRUE(ret == TDM_ERROR_NONE); @@ -1191,6 +1222,8 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerDifferentData) continue; if (ut_tdm_layer_is_video_layer(layers[l])) continue; + if (ut_tdm_layer_is_primary_layer(layers[l])) + continue; for (int t = 0; t < 10; t++) { bool done1 = false, done2 = false, done3 = false; @@ -1199,7 +1232,7 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerDifferentData) ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done3) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_layer_remove_commit_handler(layers[l], _ut_tdm_layer_commit_cb, NULL) == TDM_ERROR_NONE); while (!done1 || !done2 || !done3) { - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); } } } @@ -1219,9 +1252,12 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerInHandler) { TDM_UT_SKIP_FLAG(has_layers); - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); + ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + tdm_error ret; tdm_output *output = tdm_layer_get_output(layers[l], &ret); ASSERT_TRUE(ret == TDM_ERROR_NONE); @@ -1231,6 +1267,8 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerInHandler) continue; if (ut_tdm_layer_is_video_layer(layers[l])) continue; + if (ut_tdm_layer_is_primary_layer(layers[l])) + continue; for (int t = 0; t < 10; t++) { bool done1 = false, done2 = false, done3 = false; @@ -1238,7 +1276,7 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerInHandler) ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb2, &done2) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb2, &done3) == TDM_ERROR_NONE); while (!done1 || !done2 || !done3) { - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); } } } @@ -1293,10 +1331,12 @@ TEST_P(TDMLayer, LayerSetBufferQueue) tdm_error ret; - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); + ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { - unsigned int usable; + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + tdm_info_layer info; tbm_surface_h buffer; tbm_surface_h displaying_buffer; @@ -1305,6 +1345,8 @@ TEST_P(TDMLayer, LayerSetBufferQueue) continue; if (ut_tdm_layer_is_video_layer(layers[l])) continue; + if (ut_tdm_layer_is_primary_layer(layers[l])) + continue; ASSERT_TRUE(ut_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue) == true); ASSERT_TRUE(buffer_queue != NULL); @@ -1315,12 +1357,7 @@ TEST_P(TDMLayer, LayerSetBufferQueue) tbm_format bf = tbm_surface_queue_get_format(buffer_queue); ASSERT_TRUE(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info) == true); - ASSERT_TRUE(tdm_layer_is_usable(layers[l], &usable) == TDM_ERROR_NONE); - ASSERT_TRUE(usable == 1); ASSERT_TRUE(tdm_layer_set_info(layers[l], &info) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_is_usable(layers[l], &usable) == TDM_ERROR_NONE); - ASSERT_TRUE(usable == 0); - ASSERT_TRUE(tdm_layer_set_buffer_queue(layers[l], buffer_queue) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_layer_commit(layers[l], NULL, NULL) == TDM_ERROR_NONE); @@ -1332,12 +1369,11 @@ TEST_P(TDMLayer, LayerSetBufferQueue) ASSERT_TRUE(tbm_surface_queue_enqueue(buffer_queue, buffer) == TBM_SURFACE_QUEUE_ERROR_NONE); displaying_buffer = NULL; - while (!displaying_buffer) { - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + while (displaying_buffer != buffer) { + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret); ASSERT_TRUE(ret == TDM_ERROR_NONE); } - ASSERT_TRUE(displaying_buffer == buffer); } ASSERT_TRUE(tdm_layer_unset_buffer_queue(layers[l]) == TDM_ERROR_NONE); @@ -1350,12 +1386,14 @@ TEST_P(TDMLayer, LayerSetBufferQueueTwice) { TDM_UT_SKIP_FLAG(has_layers); - _ut_tdm_layer_mode_setting_all_output(dpy, outputs, output_count); + ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { tbm_surface_queue_h buffer_queue1 = NULL; tbm_surface_queue_h buffer_queue2 = NULL; + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; if (ut_tdm_layer_is_cursor_layer(layers[l])) continue; if (ut_tdm_layer_is_video_layer(layers[l])) @@ -1411,6 +1449,9 @@ TEST_P(TDMLayer, LayerSetVideoPos) TDM_UT_SKIP_FLAG(has_layers); for (int l = 0; l < layer_count; ++l) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + if (!ut_tdm_layer_is_video_layer(layers[l])) continue; ASSERT_TRUE(tdm_layer_set_video_pos(layers[l], -1) == TDM_ERROR_NONE); @@ -1429,6 +1470,9 @@ TEST_P(TDMLayer, LayerSetVideoPosNoVideoLayer) TDM_UT_SKIP_FLAG(has_layers); for (int l = 0; l < layer_count; ++l) { + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + if (ut_tdm_layer_is_video_layer(layers[l])) continue; @@ -1442,8 +1486,12 @@ TEST_P(TDMLayer, LayerCreateCapture) for (int l = 0; l < layer_count; ++l) { tdm_error ret; - tdm_capture *capture = tdm_layer_create_capture(layers[l], &ret); + tdm_capture *capture; + + if (!ut_tdm_layer_is_avaiable(layers[l])) + continue; + capture = tdm_layer_create_capture(layers[l], &ret); if (ret == TDM_ERROR_NONE) ASSERT_TRUE(capture != NULL); } @@ -1459,8 +1507,12 @@ TEST_P(TDMLayer, LayerCreateCaptureNullObject) ASSERT_TRUE(capture == NULL); } +#ifdef TDM_UT_TEST_WITH_PARAMS INSTANTIATE_TEST_CASE_P(TDMLayerParams, TDMLayer, Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE))); - +#else +INSTANTIATE_TEST_CASE_P(TDMLayerParams, + TDMLayer, + Values(TDM_DEFAULT_MODULE)); #endif diff --git a/utests/src/ut_tdm_log.cpp b/utests/src/ut_tdm_log.cpp index 64f6154..e8fee79 100644 --- a/utests/src/ut_tdm_log.cpp +++ b/utests/src/ut_tdm_log.cpp @@ -30,8 +30,6 @@ #include "ut_tdm.h" -#ifdef UT_TDM_LOG_ENABLE - TEST(TDMLog, logPrintf) { tdm_log_enable_color(1); @@ -88,4 +86,3 @@ TEST(TDMLog, logDlogUnknownLevel) tdm_log_print(TDM_UT_INVALID_VALUE, "utest"); } -#endif diff --git a/utests/src/ut_tdm_output.cpp b/utests/src/ut_tdm_output.cpp index e543a55..32aa528 100644 --- a/utests/src/ut_tdm_output.cpp +++ b/utests/src/ut_tdm_output.cpp @@ -30,11 +30,16 @@ #include "ut_tdm.h" +static void _ut_tdm_output_change_cb(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data); +static void _ut_tdm_output_change_cb2(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data); + TDMOutput::TDMOutput() { has_outputs = false; output_count = TDM_UT_INVALID_VALUE; outputs = NULL; + + done1 = done2 = done3 = false; } void TDMOutput::SetUp(void) @@ -63,7 +68,17 @@ void TDMOutput::SetUp(void) void TDMOutput::TearDown(void) { - free(outputs); + if (outputs) { + for (int o = 0; o < output_count; o++) { + ASSERT_TRUE(ut_tdm_output_unset(dpy, outputs[o]) == true); + tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1); + tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, &done2); + tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, &done3); + tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, NULL); + } + free(outputs); + } + TDMDisplay::TearDown(); } @@ -136,6 +151,23 @@ ut_tdm_output_is_connected(tdm_output *output) return (status != TDM_OUTPUT_CONN_STATUS_DISCONNECTED) ? true : false; } +tdm_layer * +ut_tdm_output_get_primary_layer(tdm_output *output) +{ + tdm_error ret; + tdm_layer *layer; + int primary_index = -1; + + TDM_UT_RETURN_VAL_IF_FAIL(tdm_output_get_primary_index(output, &primary_index) == TDM_ERROR_NONE, NULL); + TDM_UT_RETURN_VAL_IF_FAIL(primary_index >= 0, NULL); + + layer = tdm_output_get_layer(output, primary_index, &ret); + TDM_UT_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, NULL); + TDM_UT_RETURN_VAL_IF_FAIL(layer != NULL, NULL); + + return layer; +} + static void _ut_tdm_output_done_cb(tdm_output *output, unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, @@ -147,90 +179,69 @@ _ut_tdm_output_done_cb(tdm_output *output, unsigned int sequence, } bool -ut_tdm_output_prepare(tdm_display *dpy, tdm_output *output) +ut_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill) { - tbm_surface_h *buffers = NULL; + tbm_surface_h buffer = NULL; tdm_error ret; - int count = 0, commit_buffer_count = 0, display_buffer_count = 0; - unsigned int pipe = 0; + int primary_index = -1; + tdm_info_layer info; + tdm_layer *layer; + bool done = false; TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_output_is_connected(output) == true); TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_output_mode_setting(output) == true); TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); - TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_layer_count(output, &count) == TDM_ERROR_NONE); - TDM_UT_RETURN_FALSE_IF_FAIL(count > 0); + TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_primary_index(output, &primary_index) == TDM_ERROR_NONE); + TDM_UT_RETURN_FALSE_IF_FAIL(primary_index >= 0); - buffers = (tbm_surface_h *)calloc(count, sizeof (tbm_surface_h)); - TDM_UT_RETURN_FALSE_IF_FAIL(buffers != NULL); + layer = tdm_output_get_layer(output, primary_index, &ret); + TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE); + TDM_UT_RETURN_FALSE_IF_FAIL(layer != NULL); - for (int l = 0; l < count; l++) { - tdm_info_layer info; - tdm_layer *layer = tdm_output_get_layer(output, l, &ret); - TDM_UT_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, failed); - TDM_UT_GOTO_IF_FAIL(layer != NULL, failed); - - if (ut_tdm_layer_is_cursor_layer(layer)) - continue; - if (ut_tdm_layer_is_video_layer(layer)) - continue; + TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_layer_prepare_buffer(layer, &buffer, 1, fill) == true); + TDM_UT_RETURN_FALSE_IF_FAIL(buffer != NULL); - TDM_UT_GOTO_IF_FAIL(ut_tdm_layer_prepare_buffer(layer, &buffers[l], 1) == true, failed); - TDM_UT_GOTO_IF_FAIL(buffers[l] != NULL, failed); + int bw = tbm_surface_get_width(buffer); + int bh = tbm_surface_get_height(buffer); + tbm_format bf = tbm_surface_get_format(buffer); + TDM_UT_GOTO_IF_FAIL(ut_tdm_layer_fill_info(layer, bw, bh, bf, &info) == true, failed); - int bw = tbm_surface_get_width(buffers[l]); - int bh = tbm_surface_get_height(buffers[l]); - tbm_format bf = tbm_surface_get_format(buffers[l]); - TDM_UT_GOTO_IF_FAIL(ut_tdm_layer_fill_info(layer, bw, bh, bf, &info) == true, failed); + TDM_UT_GOTO_IF_FAIL(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE, failed); + TDM_UT_GOTO_IF_FAIL(tdm_layer_set_buffer(layer, buffer) == TDM_ERROR_NONE, failed); - TDM_UT_GOTO_IF_FAIL(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE, failed); - TDM_UT_GOTO_IF_FAIL(tdm_layer_set_buffer(layer, buffers[l]) == TDM_ERROR_NONE, failed); + if (tdm_helper_output_commit_per_vblank_enabled(output)) TDM_UT_GOTO_IF_FAIL(tdm_layer_commit(layer, NULL, NULL) == TDM_ERROR_NONE, failed); - commit_buffer_count++; - } + else + TDM_UT_GOTO_IF_FAIL(tdm_output_commit(output, 0, NULL, NULL) == TDM_ERROR_NONE, failed); - while (commit_buffer_count != display_buffer_count) { - TDM_UT_GOTO_IF_FAIL(tdm_output_wait_vblank(output, 1, 0, _ut_tdm_output_done_cb, NULL) == TDM_ERROR_NONE, failed); - TDM_UT_GOTO_IF_FAIL(tdm_display_handle_events(dpy) == TDM_ERROR_NONE, failed); - - display_buffer_count = 0; - for (int l = 0; l < count; l++) { - tbm_surface_h displaying_buffer; - tdm_layer *layer = tdm_output_get_layer(output, l, &ret); - TDM_UT_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, failed); - TDM_UT_GOTO_IF_FAIL(layer != NULL, failed); - - if (ut_tdm_layer_is_cursor_layer(layer)) - continue; - if (ut_tdm_layer_is_video_layer(layer)) - continue; - - displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); - if (displaying_buffer) { - TDM_UT_GOTO_IF_FAIL(displaying_buffer == buffers[l], failed); - display_buffer_count++; - } - } + while (!done) { + TDM_UT_GOTO_IF_FAIL(tdm_output_wait_vblank(output, 1, 0, _ut_tdm_output_done_cb, &done) == TDM_ERROR_NONE, failed); + TDM_UT_GOTO_IF_FAIL(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE, failed); } - for (int l = 0; l < count; l++) - tbm_surface_destroy(buffers[l]); - - free(buffers); - - TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE); - - TDM_INFO("preparing output(%d) done", pipe); + tbm_surface_internal_unref(buffer); return true; failed: - for (int l = 0; l < count; l++) - tbm_surface_destroy(buffers[l]); - free(buffers); + tbm_surface_internal_unref(buffer); + return false; } bool +ut_tdm_output_prepare_all_output(tdm_display *dpy, tdm_output **outputs, int output_count, bool fill) +{ + for (int o = 0; o < output_count; o++) { + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + if (!ut_tdm_output_prepare(dpy, outputs[o], fill)) + return false; + } + return true; +} + +bool ut_tdm_output_unset(tdm_display *dpy, tdm_output *output) { tdm_error ret; @@ -274,8 +285,6 @@ ut_tdm_output_get_vblank_interval_time(tdm_output *output) return (double)1.0 / (double)mode->vrefresh; } -#ifdef UT_TDM_OUTPUT_ENABLE - TEST_P(TDMOutput, OutputGetBackendModule) { TDM_UT_SKIP_FLAG(has_outputs); @@ -543,6 +552,9 @@ TEST_P(TDMOutput, OutputGetAvailableModes) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + int count = TDM_UT_INVALID_VALUE; const tdm_output_mode *modes_array = (const tdm_output_mode *) TDM_UT_INVALID_VALUE; ASSERT_TRUE(tdm_output_get_available_modes(outputs[o], &modes_array, &count) == TDM_ERROR_NONE); @@ -574,6 +586,9 @@ TEST_P(TDMOutput, OutputGetAvailableSize) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE; int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE; int preferred_align = TDM_UT_INVALID_VALUE; @@ -875,20 +890,18 @@ TEST_P(TDMOutput, OutputAddChangeHandler) { TDM_UT_SKIP_FLAG(has_outputs); - bool done; - for (int o = 0; o < output_count; o++) { if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); - done = false; - ASSERT_TRUE(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done) == TDM_ERROR_NONE); + done1 = false; + ASSERT_TRUE(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); - ASSERT_TRUE(done == true); + ASSERT_TRUE(done1 == true); } } @@ -919,7 +932,7 @@ TEST_P(TDMOutput, OutputRemoveChangeHandler) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - for (int t = 0; t < 100; t++) { + for (int t = 0; t < 10; t++) { ASSERT_TRUE(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, NULL) == TDM_ERROR_NONE); tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, NULL); } @@ -930,20 +943,18 @@ TEST_P(TDMOutput, OutputRemoveChangeHandlerDifferentData) { TDM_UT_SKIP_FLAG(has_outputs); - bool done; - for (int o = 0; o < output_count; o++) { if (!ut_tdm_output_is_connected(outputs[o])) continue; ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); - done = false; - ASSERT_TRUE(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done) == TDM_ERROR_NONE); + done1 = false; + ASSERT_TRUE(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1) == TDM_ERROR_NONE); tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, NULL); ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); - ASSERT_TRUE(done == true); + ASSERT_TRUE(done1 == true); } } @@ -960,8 +971,6 @@ TEST_P(TDMOutput, OutputRemoveChangeHandlerInHandler) { TDM_UT_SKIP_FLAG(has_outputs); - bool done1, done2, done3; - for (int o = 0; o < output_count; o++) { if (!ut_tdm_output_is_connected(outputs[o])) continue; @@ -1089,7 +1098,7 @@ TEST_P(TDMOutput, OutputGetModeNoSet) } } -TEST_P(TDMOutput, OutputSetDPMS) +TEST_P(TDMOutput, OutputSetDpms) { TDM_UT_SKIP_FLAG(has_outputs); @@ -1109,14 +1118,14 @@ TEST_P(TDMOutput, OutputSetDPMS) } } -TEST_P(TDMOutput, OutputSetDPMSNullObject) +TEST_P(TDMOutput, OutputSetDpmsNullObject) { TDM_UT_SKIP_FLAG(has_outputs); ASSERT_TRUE(tdm_output_set_dpms(NULL, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_INVALID_PARAMETER); } -TEST_P(TDMOutput, OutputSetDPMSNullOther) +TEST_P(TDMOutput, OutputSetDpmsNullOther) { TDM_UT_SKIP_FLAG(has_outputs); @@ -1124,28 +1133,27 @@ TEST_P(TDMOutput, OutputSetDPMSNullOther) ASSERT_TRUE(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)INT_MAX) == TDM_ERROR_BAD_REQUEST); } -TEST_P(TDMOutput, OutputSetDPMSAsync) +TEST_P(TDMOutput, OutputSetDpmsAsync) { TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - bool done = false; - if (!ut_tdm_output_is_connected(outputs[o])) continue; if (!ut_tdm_output_is_async_dpms_enable(outputs[o])) continue; + done1 = false; ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_set_dpms_async(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); - while(!done) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); - tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, &done); + while (!done1) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1); } } -TEST_P(TDMOutput, OutputGetDPMS) +TEST_P(TDMOutput, OutputGetDpms) { TDM_UT_SKIP_FLAG(has_outputs); @@ -1181,7 +1189,7 @@ TEST_P(TDMOutput, OutputGetDPMS) } } -TEST_P(TDMOutput, OutputGetDPMSNullObject) +TEST_P(TDMOutput, OutputGetDpmsNullObject) { TDM_UT_SKIP_FLAG(has_outputs); @@ -1190,7 +1198,7 @@ TEST_P(TDMOutput, OutputGetDPMSNullObject) ASSERT_TRUE(dpms_value == (tdm_output_dpms)TDM_UT_INVALID_VALUE); } -TEST_P(TDMOutput, OutputGetDPMSNullOther) +TEST_P(TDMOutput, OutputGetDpmsNullOther) { TDM_UT_SKIP_FLAG(has_outputs); @@ -1205,18 +1213,18 @@ TEST_P(TDMOutput, OutputWaitVblank) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); for (int t = 0; t < 10; t++) { - bool done = false; double start, end, interval; interval = ut_tdm_output_get_vblank_interval_time(outputs[o]); + done1 = false; start = tdm_helper_get_time(); - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], 1, 0, _ut_tdm_output_done_cb, &done) == TDM_ERROR_NONE); - while(!done) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], 1, 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); + while (!done1) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -1240,7 +1248,8 @@ TEST_P(TDMOutput, OutputWaitVblankNullOther) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], 1, 0, NULL, NULL) == TDM_ERROR_NONE); } } @@ -1253,12 +1262,12 @@ TEST_P(TDMOutput, OutputWaitVblankTimeout) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], 1, 0, _ut_tdm_output_done_cb, NULL) == TDM_ERROR_NONE); usleep(1100000); - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_helper_output_vblank_timer_expired(outputs[o]) > 0); } @@ -1279,19 +1288,19 @@ TEST_P(TDMOutput, OutputWaitVblankInterval) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); /* start from 1 */ for (int t = 1; t < 10; t++) { - bool done = false; double start, end, interval; interval = ut_tdm_output_get_vblank_interval_time(outputs[o]); + done1 = false; start = tdm_helper_get_time(); - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done) == TDM_ERROR_NONE); - while(!done) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); + while (!done1) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -1309,27 +1318,27 @@ TEST_P(TDMOutput, OutputWaitVblankFewTimesInOneVblank) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); /* start from 1 */ for (int t = 1; t < 10; t++) { - bool done1 = false, done2 = false, done3 = false; double start, end, interval; interval = ut_tdm_output_get_vblank_interval_time(outputs[o]); + done1 = done2 = done3 = false; ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3) == TDM_ERROR_NONE); - while(!done1 || !done2 || !done3) { - start = tdm_helper_get_time(); - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); - end = tdm_helper_get_time(); - /* "+ interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) > (interval * (t - 1))); - ASSERT_TRUE((end - start) < (interval * t + interval)); - } + start = tdm_helper_get_time(); + while (!done1 || !done2 || !done3) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + end = tdm_helper_get_time(); + + /* "+ interval" consider the delay of socket communication between kernel and platform */ + ASSERT_TRUE((end - start) > (interval * (t - 1))); + ASSERT_TRUE((end - start) < (interval * t + interval)); } } } @@ -1342,7 +1351,7 @@ TEST_P(TDMOutput, OutputWaitVblankBeforeDpmsOff) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], false) == true); for (int t = 0; t < 10; t++) { bool done = false; @@ -1364,17 +1373,17 @@ TEST_P(TDMOutput, OutputRemoveVblankHandler) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); /* start from 1 */ for (int t = 1; t < 10; t++) { - bool done1 = false, done2 = false, done3 = false; + done1 = done2 = done3 = false; ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3) == TDM_ERROR_NONE); tdm_output_remove_vblank_handler(outputs[o], _ut_tdm_output_done_cb, &done2); - while(!done1 || done2 || !done3) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + while (!done1 || done2 || !done3) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); } } } @@ -1387,17 +1396,17 @@ TEST_P(TDMOutput, OutputRemoveVblankHandlerDifferentData) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + ut_tdm_output_prepare(dpy, outputs[o], true); /* start from 1 */ for (int t = 1; t < 10; t++) { - bool done1 = false, done2 = false, done3 = false; + done1 = done2 = done3 = false; ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3) == TDM_ERROR_NONE); tdm_output_remove_vblank_handler(outputs[o], _ut_tdm_output_done_cb, NULL); - while(!done1 || !done2 || !done3) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + while (!done1 || !done2 || !done3) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); } } } @@ -1421,16 +1430,16 @@ TEST_P(TDMOutput, OutputRemoveVblankHandlerInHandler) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); /* start from 1 */ for (int t = 1; t < 10; t++) { - bool done1 = false, done2 = false, done3 = false; + done1 = done2 = done3 = false; ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3) == TDM_ERROR_NONE); - while(!done1 || !done2 || !done3) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + while (!done1 || !done2 || !done3) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); } } } @@ -1447,18 +1456,18 @@ TEST_P(TDMOutput, OutputCommit) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); for (int t = 0; t < 10; t++) { - bool done = false; double start, end, interval; interval = ut_tdm_output_get_vblank_interval_time(outputs[o]); + done1 = false; start = tdm_helper_get_time(); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done) == TDM_ERROR_NONE); - while(!done) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); + while (!done1) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -1503,7 +1512,7 @@ TEST_P(TDMOutput, OutputCommitDpmsSuspend) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND) == TDM_ERROR_NONE); @@ -1523,7 +1532,7 @@ TEST_P(TDMOutput, OutputCommitDpmsOff) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); @@ -1546,15 +1555,15 @@ TEST_P(TDMOutput, OutputCommitDpmsAOD) if (!ut_tdm_output_is_aod_enable(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD) == TDM_ERROR_NONE); for (int t = 0; t < 10; t++) { - bool done = false; - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done) == TDM_ERROR_NONE); - while(!done) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + done1 = false; + ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); + while (!done1) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); } } } @@ -1568,7 +1577,10 @@ TEST_P(TDMOutput, OutputCommitAfterLayerCommit) tdm_layer *layer; tdm_error ret; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); ASSERT_TRUE(tdm_output_get_primary_index(outputs[o], &index) == TDM_ERROR_NONE); ASSERT_TRUE(index != TDM_UT_INVALID_VALUE); @@ -1609,19 +1621,25 @@ TEST_P(TDMOutput, OutputCommitFewTimesInOneVblank) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); for (int t = 0; t < 10; t++) { - bool done1 = false, done2 = false, done3 = false; + done1 = done2 = done3 = false; ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done2) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done3) == TDM_ERROR_NONE); - while(!done1 || !done2 || !done3) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + while (!done1 || !done2 || !done3) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); } } } +//TODO +TEST_P(TDMOutput, DISABLED_OutputCommitBeforeDpmsOff) +{ + /* output commit -> dpms off -> then? (commit handler is called? or not?) */ +} + TEST_P(TDMOutput, OutputRemoveCommitHandler) { TDM_UT_SKIP_FLAG(has_outputs); @@ -1634,16 +1652,16 @@ TEST_P(TDMOutput, OutputRemoveCommitHandler) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); for (int t = 0; t < 10; t++) { - bool done1 = false, done2 = false, done3 = false; + done1 = done2 = done3 = false; ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done2) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done3) == TDM_ERROR_NONE); tdm_output_remove_commit_handler(outputs[o], _ut_tdm_output_done_cb, &done2); - while(!done1 || done2 || !done3) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + while (!done1 || done2 || !done3) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); } } } @@ -1660,16 +1678,16 @@ TEST_P(TDMOutput, OutputRemoveCommitHandlerDifferentData) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); for (int t = 0; t < 10; t++) { - bool done1 = false, done2 = false, done3 = false; + done1 = done2 = done3 = false; ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done2) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done3) == TDM_ERROR_NONE); tdm_output_remove_commit_handler(outputs[o], _ut_tdm_output_done_cb, NULL); - while(!done1 || !done2 || !done3) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + while (!done1 || !done2 || !done3) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); } } } @@ -1686,21 +1704,25 @@ TEST_P(TDMOutput, OutputRemoveCommitHandlerInHandler) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); for (int t = 0; t < 10; t++) { - bool done1 = false, done2 = false, done3 = false; + done1 = done2 = done3 = false; ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb2, &done1) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb2, &done2) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb2, &done3) == TDM_ERROR_NONE); - while(!done1 || !done2 || !done3) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + while (!done1 || !done2 || !done3) + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); } } } +#ifdef TDM_UT_TEST_WITH_PARAMS INSTANTIATE_TEST_CASE_P(TDMOutputParams, TDMOutput, Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE))); - -#endif +#else +INSTANTIATE_TEST_CASE_P(TDMOutputParams, + TDMOutput, + Values(TDM_DEFAULT_MODULE)); +#endif \ No newline at end of file diff --git a/utests/src/ut_tdm_output_hwc.cpp b/utests/src/ut_tdm_output_hwc.cpp index 1b0aa24..1695e6b 100644 --- a/utests/src/ut_tdm_output_hwc.cpp +++ b/utests/src/ut_tdm_output_hwc.cpp @@ -54,8 +54,6 @@ void TDMOutputHwc::TearDown(void) TDMOutput::TearDown(); } -#ifdef UT_TDM_OUTPUT_HWC_ENABLE - /* tdm_hwc_window * tdm_output_hwc_create_window(tdm_output *output, tdm_error *error); */ TEST_P(TDMOutputHwc, CreateWindowFailNull) { @@ -441,7 +439,12 @@ TEST_P(TDMOutputHwc, GetVideoSupportedFormatsSuccessful) } } +#ifdef TDM_UT_TEST_WITH_PARAMS INSTANTIATE_TEST_CASE_P(TDMOutputHwcParams, TDMOutputHwc, Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE))); +#else +INSTANTIATE_TEST_CASE_P(TDMOutputHwcParams, + TDMOutputHwc, + Values(TDM_DEFAULT_MODULE)); #endif diff --git a/utests/src/ut_tdm_vblank.cpp b/utests/src/ut_tdm_vblank.cpp index 3b3e8e3..a7bf51c 100644 --- a/utests/src/ut_tdm_vblank.cpp +++ b/utests/src/ut_tdm_vblank.cpp @@ -30,6 +30,9 @@ #include "ut_tdm.h" +static void _ut_tdm_vblank_create_cb(tdm_vblank *vblank, void *user_data); +static void _ut_tdm_vblank_create_cb2(tdm_vblank *vblank, void *user_data); + class TDMVblank : public TDMOutput { public: @@ -66,6 +69,11 @@ void TDMVblank::SetUp(void) void TDMVblank::TearDown(void) { + tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this); + tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL); + tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb2, this); + tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb2, NULL); + TestDestroyVblanks(); tdm_vblank_enable_global_fps(0, 0); @@ -149,7 +157,7 @@ bool TDMVblank::TestPrepareOutput(void) if (!ut_tdm_output_is_connected(outputs[o])) continue; - TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_output_prepare(dpy, outputs[o]) == true); + TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_output_prepare(dpy, outputs[o], false) == true); } return true; @@ -162,11 +170,10 @@ bool ut_tdm_vblank_is_avaiable(tdm_vblank *vblank) TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE); TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL); + /* only check if connected */ return ut_tdm_output_is_connected(output); } -#ifdef UT_TDM_VBLANK_ENABLE - /* tdm_vblank_set_client_vblank_fps */ TEST_P(TDMVblank, DISABLED_VblankSetClientVblankFps) { @@ -884,7 +891,7 @@ _ut_tdm_vblank_cb(tdm_vblank *vblank, tdm_error error, unsigned int sequence, { unsigned int *cur_seq = (unsigned int *)user_data; if (cur_seq) - *cur_seq = sequence; + *cur_seq = (error == TDM_ERROR_NONE) ? sequence : ((unsigned int)-1); } TEST_P(TDMVblank, VblankWait) @@ -911,7 +918,7 @@ TEST_P(TDMVblank, VblankWait) start = tdm_helper_get_time(); ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -947,7 +954,7 @@ TEST_P(TDMVblank, VblankWaitFewTime) ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &seq1) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &seq2) == TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); end = tdm_helper_get_time(); ASSERT_TRUE(seq1 != 0); @@ -994,7 +1001,7 @@ TEST_P(TDMVblank, VblankWaitInterval) start = tdm_helper_get_time(); ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, t, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -1027,12 +1034,12 @@ TEST_P(TDMVblank, VblankWaitSeq) ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); start = tdm_helper_get_time(); ASSERT_TRUE(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + 1, _ut_tdm_vblank_cb, &temp) == TDM_ERROR_NONE); while (temp == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -1065,12 +1072,12 @@ TEST_P(TDMVblank, VblankWaitSeqInterval) ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); start = tdm_helper_get_time(); ASSERT_TRUE(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + t, _ut_tdm_vblank_cb, &temp) == TDM_ERROR_NONE); while (temp == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); end = tdm_helper_get_time(); #if 0 @@ -1118,8 +1125,6 @@ TEST_P(TDMVblank, VblankWaitDpmsOff) if (!ut_tdm_output_is_connected(output)) continue; - ASSERT_TRUE(ut_tdm_output_unset(dpy, output) == true); - ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL) == TDM_ERROR_DPMS_OFF); @@ -1142,8 +1147,6 @@ TEST_P(TDMVblank, VblankWaitBeforeDpmsOff) if (!ut_tdm_output_is_connected(output)) continue; - ASSERT_TRUE(ut_tdm_output_unset(dpy, output) == true); - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &temp) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); @@ -1171,8 +1174,6 @@ TEST_P(TDMVblank, VblankWaitSetEnableFakeDpmsOff) if (!ut_tdm_output_is_connected(output)) continue; - ASSERT_TRUE(ut_tdm_output_unset(dpy, output) == true); - ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); ASSERT_TRUE(tdm_vblank_set_enable_fake(vblanks[v], 1) == TDM_ERROR_NONE); @@ -1226,7 +1227,7 @@ TEST_P(TDMVblank, VblankWaitSetOffset) start = tdm_helper_get_time(); ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -1264,7 +1265,7 @@ TEST_P(TDMVblank, VblankWaitSetFps) start = tdm_helper_get_time(); ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ @@ -1304,7 +1305,7 @@ TEST_P(TDMVblank, VblankWaitSetFixedFps) start = tdm_helper_get_time(); ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ @@ -1349,7 +1350,7 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps) start = tdm_helper_get_time(); while (cur_seq[2] == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+- vrefresh_interval" consider the delay of socket communication between kernel and platform */ @@ -1360,11 +1361,11 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps) ASSERT_TRUE(cur_seq[0] == 0); while (cur_seq[1] == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); ASSERT_TRUE(cur_seq[0] == 0); while (cur_seq[0] == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); /* disable test. global fps doesn't effect server's vblanks */ tdm_vblank_enable_global_fps(0, 0); @@ -1375,12 +1376,12 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps) } while (cur_seq[2] == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); ASSERT_TRUE(cur_seq[1] == 0); ASSERT_TRUE(cur_seq[0] == 0); while (cur_seq[1] == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); ASSERT_TRUE(cur_seq[0] == 0); } @@ -1408,8 +1409,17 @@ TEST_P(TDMVblank, VblankWaitSetEnableFakeDisconnected) } } +TEST_P(TDMVblank, DISABLED_VblankWaitBeforeDpmsOff) +{ + /* wait vblank -> dpms off -> then? (vblank handler is called? or not?) */ +} + +#ifdef TDM_UT_TEST_WITH_PARAMS INSTANTIATE_TEST_CASE_P(TDMVblankParams, TDMVblank, Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE))); - -#endif +#else +INSTANTIATE_TEST_CASE_P(TDMVblankParams, + TDMVblank, + Values(TDM_DEFAULT_MODULE)); +#endif \ No newline at end of file -- 2.7.4 From ef7fb2e034da8db7c35bc22ca30e3816d9c13903 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Tue, 13 Mar 2018 15:52:57 +0900 Subject: [PATCH 15/16] utests: using ASSERT_XXX Change-Id: Ib3b039753e6f3400eb22672c1af2a2f12e500ff0 --- utests/src/ut_tdm_backend_capture.cpp | 170 +++++----- utests/src/ut_tdm_backend_display.cpp | 478 +++++++++++++-------------- utests/src/ut_tdm_backend_pp.cpp | 144 ++++----- utests/src/ut_tdm_buffer.cpp | 78 ++--- utests/src/ut_tdm_client.cpp | 528 +++++++++++++++--------------- utests/src/ut_tdm_display.cpp | 190 +++++------ utests/src/ut_tdm_env.cpp | 29 +- utests/src/ut_tdm_event_loop.cpp | 54 ++-- utests/src/ut_tdm_helper.cpp | 106 +++--- utests/src/ut_tdm_layer.cpp | 366 ++++++++++----------- utests/src/ut_tdm_output.cpp | 592 +++++++++++++++++----------------- utests/src/ut_tdm_output_hwc.cpp | 2 +- utests/src/ut_tdm_vblank.cpp | 530 +++++++++++++++--------------- 13 files changed, 1633 insertions(+), 1634 deletions(-) diff --git a/utests/src/ut_tdm_backend_capture.cpp b/utests/src/ut_tdm_backend_capture.cpp index ecbe06b..6482b4b 100644 --- a/utests/src/ut_tdm_backend_capture.cpp +++ b/utests/src/ut_tdm_backend_capture.cpp @@ -84,7 +84,7 @@ void TDMBackendCapture::SetUp(void) TDMBackendDisplay::SetUp(); - ASSERT_TRUE(tdm_display_get_capabilities(dpy, &dpy_capabilities) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_display_get_capabilities(dpy, &dpy_capabilities), TDM_ERROR_NONE); has_capture_cap = dpy_capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE; if (!has_capture_cap) @@ -94,7 +94,7 @@ void TDMBackendCapture::SetUp(void) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); } } @@ -107,7 +107,7 @@ void TDMBackendCapture::TearDown(void) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_unset(dpy, outputs[o]) == true); + ASSERT_EQ(ut_tdm_output_unset(dpy, outputs[o]), true); } DestroyBuffers(); @@ -293,13 +293,13 @@ TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableFormats) const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; if (has_capture_cap) { - ASSERT_TRUE(tdm_display_get_capture_available_formats(dpy, &formats, &count) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_display_get_capture_available_formats(dpy, &formats, &count), TDM_ERROR_NONE); ASSERT_TRUE(formats != NULL && formats != (const tbm_format *)TDM_UT_INVALID_VALUE); ASSERT_TRUE(count > 0 && count != TDM_UT_INVALID_VALUE); } else { - ASSERT_TRUE(tdm_display_get_capture_available_formats(dpy, &formats, &count) == TDM_ERROR_NO_CAPABILITY); - ASSERT_TRUE(formats == (const tbm_format *)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(count == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_capture_available_formats(dpy, &formats, &count), TDM_ERROR_NO_CAPABILITY); + ASSERT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE); + ASSERT_EQ(count, TDM_UT_INVALID_VALUE); } } @@ -307,14 +307,14 @@ TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableFormatsNullObject) { const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_capture_available_formats(NULL, &formats, &count) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(formats == (const tbm_format *)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(count == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_capture_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE); + ASSERT_EQ(count, TDM_UT_INVALID_VALUE); } TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableFormatsNullOther) { - ASSERT_TRUE(tdm_display_get_capture_available_formats(dpy, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_display_get_capture_available_formats(dpy, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableSize) @@ -325,19 +325,19 @@ TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableSize) int max_h = TDM_UT_INVALID_VALUE; int preferred_align = TDM_UT_INVALID_VALUE; if (has_capture_cap) { - ASSERT_TRUE(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align) == TDM_ERROR_NONE); - ASSERT_TRUE(min_w != TDM_UT_INVALID_VALUE); - ASSERT_TRUE(min_h != TDM_UT_INVALID_VALUE); - ASSERT_TRUE(max_w != TDM_UT_INVALID_VALUE); - ASSERT_TRUE(max_h != TDM_UT_INVALID_VALUE); - ASSERT_TRUE(preferred_align != TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE); + ASSERT_NE(min_w, TDM_UT_INVALID_VALUE); + ASSERT_NE(min_h, TDM_UT_INVALID_VALUE); + ASSERT_NE(max_w, TDM_UT_INVALID_VALUE); + ASSERT_NE(max_h, TDM_UT_INVALID_VALUE); + ASSERT_NE(preferred_align, TDM_UT_INVALID_VALUE); } else { - ASSERT_TRUE(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align) == TDM_ERROR_NO_CAPABILITY); - ASSERT_TRUE(min_w == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(min_h == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(max_w == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(max_h == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(preferred_align == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NO_CAPABILITY); + ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE); + ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE); + ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE); + ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE); + ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE); } } @@ -348,27 +348,27 @@ TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableSizeNullObject) int max_w = TDM_UT_INVALID_VALUE; int max_h = TDM_UT_INVALID_VALUE; int preferred_align = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_capture_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(min_w == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(min_h == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(max_w == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(max_h == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(preferred_align == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_capture_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE); + ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE); + ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE); + ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE); + ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE); } TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableSizeNullOther) { if (has_capture_cap) - ASSERT_TRUE(tdm_display_get_capture_available_size(dpy, NULL, NULL, NULL, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_display_get_capture_available_size(dpy, NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE); else - ASSERT_TRUE(tdm_display_get_capture_available_size(dpy, NULL, NULL, NULL, NULL, NULL) == TDM_ERROR_NO_CAPABILITY); + ASSERT_EQ(tdm_display_get_capture_available_size(dpy, NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NO_CAPABILITY); } TEST_P(TDMBackendCapture, CaptureDestroy) { TDM_UT_SKIP_FLAG(has_capture_cap); - ASSERT_TRUE(TestPrepareDefault() == true); + ASSERT_EQ(TestPrepareDefault(), true); TestDone(); } @@ -391,16 +391,16 @@ TEST_P(TDMBackendCapture, CaptureSetInfoNullObject) tdm_info_capture info; memset(&info, 0, sizeof info); - ASSERT_TRUE(tdm_capture_set_info(NULL, &info) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_capture_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendCapture, CaptureSetInfoNullOther) { TDM_UT_SKIP_FLAG(has_capture_cap); - ASSERT_TRUE(TestPrepareDefault() == true); + ASSERT_EQ(TestPrepareDefault(), true); - ASSERT_TRUE(tdm_capture_set_info(capture, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_capture_set_info(capture, NULL), TDM_ERROR_INVALID_PARAMETER); TestDone(); } @@ -417,9 +417,9 @@ TEST_P(TDMBackendCapture, CaptureSetDoneHandler) { TDM_UT_SKIP_FLAG(has_capture_cap); - ASSERT_TRUE(TestPrepareDefault() == true); + ASSERT_EQ(TestPrepareDefault(), true); - ASSERT_TRUE(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb, NULL), TDM_ERROR_NONE); TestDone(); } @@ -428,16 +428,16 @@ TEST_P(TDMBackendCapture, CaptureSetDoneHandlerNullObject) { TDM_UT_SKIP_FLAG(has_capture_cap); - ASSERT_TRUE(tdm_capture_set_done_handler(NULL, _ut_tdm_capture_done_cb, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_capture_set_done_handler(NULL, _ut_tdm_capture_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendCapture, CaptureSetDoneHandlerNullOther) { TDM_UT_SKIP_FLAG(has_capture_cap); - ASSERT_TRUE(TestPrepareDefault() == true); + ASSERT_EQ(TestPrepareDefault(), true); - ASSERT_TRUE(tdm_capture_set_done_handler(capture, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_capture_set_done_handler(capture, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); TestDone(); } @@ -455,11 +455,11 @@ TEST_P(TDMBackendCapture, CaptureAttach) if (!FindFormat(test_formats[f])) continue; - ASSERT_TRUE(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, test_formats[f], - TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1) == true); + ASSERT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, test_formats[f], + TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1), true); for (int b = 0; b < 3; b++) - ASSERT_TRUE(tdm_capture_attach(capture, buffers[b]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); TestDone(); } @@ -472,16 +472,16 @@ TEST_P(TDMBackendCapture, CaptureAttachNullObject) tbm_surface_h buffer = (tbm_surface_h)TDM_UT_BUFFER_SIZE; - ASSERT_TRUE(tdm_capture_attach(NULL, buffer) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_capture_attach(NULL, buffer), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendCapture, CaptureAttachNullOther) { TDM_UT_SKIP_FLAG(has_capture_cap); - ASSERT_TRUE(TestPrepareDefault() == true); + ASSERT_EQ(TestPrepareDefault(), true); - ASSERT_TRUE(tdm_capture_attach(capture, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_capture_attach(capture, NULL), TDM_ERROR_INVALID_PARAMETER); TestDone(); } @@ -490,9 +490,9 @@ TEST_P(TDMBackendCapture, CaptureCommit) { TDM_UT_SKIP_FLAG(has_capture_cap); - ASSERT_TRUE(TestPrepareDefault() == true); + ASSERT_EQ(TestPrepareDefault(), true); - ASSERT_TRUE(tdm_capture_commit(capture) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); TestDone(); } @@ -501,20 +501,20 @@ TEST_P(TDMBackendCapture, CaptureCommitNullOBject) { TDM_UT_SKIP_FLAG(has_capture_cap); - ASSERT_TRUE(tdm_capture_commit(NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_capture_commit(NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendCapture, CaptureCommitDpmsOff) { TDM_UT_SKIP_FLAG(has_capture_cap); - ASSERT_TRUE(TestPrepareDefault() == true); + ASSERT_EQ(TestPrepareDefault(), true); - ASSERT_TRUE(ut_tdm_output_unset(dpy, output) == true); + ASSERT_EQ(ut_tdm_output_unset(dpy, output), true); - ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_capture_commit(capture) == TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_BAD_REQUEST); TestDone(); } @@ -531,7 +531,7 @@ TEST_P(TDMBackendCapture, CaptureNoScaleNoTransformNoCSC) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(tdm_output_get_mode(outputs[o], &mode) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); for (int f = 0; f < TEST_FORMAT_CNT; f++) { char temp[256]; @@ -540,18 +540,18 @@ TEST_P(TDMBackendCapture, CaptureNoScaleNoTransformNoCSC) if (!FindFormat(test_formats[f])) continue; - ASSERT_TRUE(TestPrepare(o, mode->hdisplay, mode->vdisplay, test_formats[f], - TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1) == true); + ASSERT_EQ(TestPrepare(o, mode->hdisplay, mode->vdisplay, test_formats[f], + TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1), true); - ASSERT_TRUE(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb, &done), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) { done = false; - ASSERT_TRUE(tdm_capture_attach(capture, buffers[b]) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_capture_commit(capture) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); while (!done) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); DumpBuffers(b, temp); } @@ -573,7 +573,7 @@ TEST_P(TDMBackendCapture, CaptureScaleTransformCSC) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(tdm_output_get_mode(outputs[o], &mode) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); for (int f = 0; f < TEST_FORMAT_CNT; f++) { char temp[256]; @@ -582,18 +582,18 @@ TEST_P(TDMBackendCapture, CaptureScaleTransformCSC) if (!FindFormat(test_formats[f])) continue; - ASSERT_TRUE(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, test_formats[f], - TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1) == true); + ASSERT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, test_formats[f], + TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1), true); - ASSERT_TRUE(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb, &done), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) { done = false; - ASSERT_TRUE(tdm_capture_attach(capture, buffers[b]) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_capture_commit(capture) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); while (!done) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); DumpBuffers(b, temp); } @@ -623,7 +623,7 @@ TEST_P(TDMBackendCapture, CaptureAttachFewTimesInOneCommit) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(tdm_output_get_mode(outputs[o], &mode) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); char temp[256]; snprintf(temp, sizeof temp, "%c%c%c%c", FOURCC_STR(test_formats[f])); @@ -631,19 +631,19 @@ TEST_P(TDMBackendCapture, CaptureAttachFewTimesInOneCommit) if (!FindFormat(test_formats[f])) continue; - ASSERT_TRUE(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, test_formats[f], - TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1) == true); + ASSERT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, test_formats[f], + TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1), true); - ASSERT_TRUE(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb2, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb2, &done), TDM_ERROR_NONE); done = 0; for (int b = 0; b < 3; b++) - ASSERT_TRUE(tdm_capture_attach(capture, buffers[b]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_capture_commit(capture) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); while (done != 3) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) DumpBuffers(b, temp); @@ -663,18 +663,18 @@ TEST_P(TDMBackendCapture, CaptureDestroyWithoutCommit) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(tdm_output_get_mode(outputs[o], &mode) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); if (!FindFormat(test_formats[f])) continue; - ASSERT_TRUE(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, test_formats[f], - TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1) == true); + ASSERT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, test_formats[f], + TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1), true); - ASSERT_TRUE(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb2, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) - ASSERT_TRUE(tdm_capture_attach(capture, buffers[b]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); tdm_capture_destroy(capture); capture = NULL; @@ -694,20 +694,20 @@ TEST_P(TDMBackendCapture, CaptureDestroyBeforeDone) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(tdm_output_get_mode(outputs[o], &mode) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); if (!FindFormat(test_formats[f])) continue; - ASSERT_TRUE(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, test_formats[f], - TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1) == true); + ASSERT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, test_formats[f], + TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1), true); - ASSERT_TRUE(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb2, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) - ASSERT_TRUE(tdm_capture_attach(capture, buffers[b]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_capture_commit(capture) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); tdm_capture_destroy(capture); capture = NULL; diff --git a/utests/src/ut_tdm_backend_display.cpp b/utests/src/ut_tdm_backend_display.cpp index a01c804..1d94fb9 100644 --- a/utests/src/ut_tdm_backend_display.cpp +++ b/utests/src/ut_tdm_backend_display.cpp @@ -51,21 +51,21 @@ void TDMBackendBasic::SetUp(void) TDMBackendEnv::SetUp(); dpy = tdm_display_init(&ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(dpy != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(dpy, NULL); - ASSERT_TRUE(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE); - ASSERT_TRUE(output_count >= 0); + ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE); + ASSERT_GE(output_count, 0); if (output_count > 0) { outputs = (tdm_output**)calloc(output_count, sizeof (tdm_output*)); - ASSERT_TRUE(outputs != NULL); + ASSERT_NE(outputs, NULL); for (int o = 0; o < output_count; o++) { tdm_error ret; tdm_output *output = tdm_display_get_output(dpy, o, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(output, NULL); outputs[o] = output; } } @@ -77,17 +77,17 @@ void TDMBackendBasic::SetUp(void) if (ut_tdm_output_is_hwc_enable(outputs[o])) continue; - ASSERT_TRUE(tdm_output_get_layer_count(outputs[o], &count) == TDM_ERROR_NONE); - ASSERT_TRUE(count > 0); + ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE); + ASSERT_GT(count, 0); layer_count += count; layers = (tdm_layer**)realloc((void*)layers, sizeof(tdm_layer*) * layer_count); - ASSERT_TRUE(layers != NULL); + ASSERT_NE(layers, NULL); for (int l = 0; l < count; l++) { tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret); - ASSERT_TRUE(layer != NULL); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_NE(layer, NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); layers[old_layer_count + l] = layer; } } @@ -108,7 +108,7 @@ void TDMBackendBasic::TearDown(void) DestroyBuffers(); - ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0); + ASSERT_EQ(tbm_bufmgr_debug_get_ref_count(), 0); TDMBackendEnv::TearDown(); } @@ -127,12 +127,12 @@ TEST_P(TDMBackendBasic, VerifyOutputObject) tdm_error ret; int output_count = 0; - ASSERT_TRUE(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE); TDM_UT_ASSERT_TRUE(output_count > 0, "output count(%d) should be greater than 0. Check display_get_outputs()."); for (int o = 0; o < output_count; o++) { tdm_output *output = tdm_display_get_output(dpy, o, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); TDM_UT_ASSERT_TRUE(output != NULL, "no output. (output: %d). Check display_get_outputs().", o); } } @@ -142,14 +142,14 @@ TEST_P(TDMBackendBasic, VerifyLayerObject) tdm_error ret; int output_count = 0; - ASSERT_TRUE(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE); for (int o = 0; o < output_count; o++) { tdm_output *output = tdm_display_get_output(dpy, o, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); int layer_count = 0; - ASSERT_TRUE(tdm_output_get_layer_count(output, &layer_count) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_layer_count(output, &layer_count), TDM_ERROR_NONE); TDM_UT_ASSERT_TRUE(layer_count > 0, "layer count(%d) should be greater than 0. (output: %d). Check output_get_layers().", layer_count, o); @@ -166,15 +166,15 @@ TEST_P(TDMBackendBasic, VerifyOutputGetProperty) tdm_error ret; int output_count = 0; - ASSERT_TRUE(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE); for (int o = 0; o < output_count; o++) { tdm_output *output = tdm_display_get_output(dpy, o, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); const tdm_prop *props = NULL; int prop_count = 0; - ASSERT_TRUE(tdm_output_get_available_properties(output, &props, &prop_count) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_available_properties(output, &props, &prop_count), TDM_ERROR_NONE); if (prop_count > 0) TDM_UT_ASSERT_TRUE(props != NULL, "no props. (output: %d). Check output_get_capability(), tdm_caps_output.", o); @@ -182,7 +182,7 @@ TEST_P(TDMBackendBasic, VerifyOutputGetProperty) for (int p = 0; p < prop_count; p++) { tdm_value value; value.s32 = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_property(output, props[p].id, &value) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_property(output, props[p].id, &value), TDM_ERROR_NONE); TDM_UT_ASSERT_TRUE(value.s32 != TDM_UT_INVALID_VALUE, "Getting a prop failed. (output: %d, prop_id: %d). Check output_get_property().", o, props[p].id); @@ -195,22 +195,22 @@ TEST_P(TDMBackendBasic, VerifyLayerGetProperty) tdm_error ret; int output_count = 0; - ASSERT_TRUE(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE); for (int o = 0; o < output_count; o++) { tdm_output *output = tdm_display_get_output(dpy, o, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); int layer_count = 0; - ASSERT_TRUE(tdm_output_get_layer_count(output, &layer_count) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_layer_count(output, &layer_count), TDM_ERROR_NONE); for (int l = 0; l < layer_count; l++) { tdm_layer *layer = tdm_output_get_layer(output, l, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); const tdm_prop *props = NULL; int prop_count = 0; - ASSERT_TRUE(tdm_layer_get_available_properties(layer, &props, &prop_count) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_get_available_properties(layer, &props, &prop_count), TDM_ERROR_NONE); if (prop_count > 0) TDM_UT_ASSERT_TRUE(props != NULL, "no props. (output: %d, layer: %d). Check output_get_capability(), tdm_caps_output.", o, l); @@ -218,7 +218,7 @@ TEST_P(TDMBackendBasic, VerifyLayerGetProperty) for (int p = 0; p < prop_count; p++) { tdm_value value; value.s32 = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_layer_get_property(layer, props[p].id, &value) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_get_property(layer, props[p].id, &value), TDM_ERROR_NONE); TDM_UT_ASSERT_TRUE(value.s32 != TDM_UT_INVALID_VALUE, "Getting a prop failed. (output: %d, layer: %d, prop_id: %d). Check output_get_property().", o, l, props[p].id); @@ -239,7 +239,7 @@ TEST_P(TDMBackendBasic, VerifyOutputSetMode) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(tdm_output_get_available_modes(outputs[o], &modes, &count) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE); TDM_UT_ASSERT_TRUE(count > 0, "mode's count should be greater than 0. Check output_get_capability(), tdm_caps_output."); TDM_UT_ASSERT_TRUE(modes != NULL, "mode's count should be greater than 0. Check output_get_capability(), tdm_caps_output."); @@ -251,10 +251,10 @@ TEST_P(TDMBackendBasic, VerifyOutputSetMode) } if (!set_mode && best) set_mode = best; - ASSERT_TRUE(set_mode != NULL); + ASSERT_NE(set_mode, NULL); - ASSERT_TRUE(tdm_output_set_mode(outputs[o], set_mode) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_get_mode(outputs[o], &got_mode) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_mode(outputs[o], set_mode), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_mode(outputs[o], &got_mode), TDM_ERROR_NONE); TDM_UT_ASSERT_TRUE(set_mode == got_mode, "The mode which is set and got are different. Check output_set_mode(), output_get_mode()"); } } @@ -273,9 +273,9 @@ TEST_P(TDMBackendBasic, VerifyOutputSetDpms) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(tdm_output_get_available_modes(outputs[o], &modes, &count) == TDM_ERROR_NONE); - ASSERT_TRUE(count > 0); - ASSERT_TRUE(modes != NULL); + ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE); + ASSERT_GT(count, 0); + ASSERT_NE(modes, NULL); for (int i = 0; i < count; i++) { if (!best) @@ -286,13 +286,13 @@ TEST_P(TDMBackendBasic, VerifyOutputSetDpms) if (!set_mode && best) set_mode = best; - ASSERT_TRUE(set_mode != NULL); - ASSERT_TRUE(tdm_output_set_mode(outputs[o], set_mode) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_get_mode(outputs[o], &got_mode) == TDM_ERROR_NONE); - ASSERT_TRUE(set_mode == got_mode); + ASSERT_NE(set_mode, NULL); + ASSERT_EQ(tdm_output_set_mode(outputs[o], set_mode), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_mode(outputs[o], &got_mode), TDM_ERROR_NONE); + ASSERT_EQ(set_mode, got_mode); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], set_dpms) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_get_dpms(outputs[o], &got_dpms) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], set_dpms), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_dpms(outputs[o], &got_dpms), TDM_ERROR_NONE); TDM_UT_ASSERT_TRUE(set_dpms == got_dpms, "The dpms value which is set and got are different. Check output_set_dpms(), output_get_dpms()"); } } @@ -305,23 +305,23 @@ TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowOneFrame) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); layer = ut_tdm_output_get_primary_layer(outputs[o]); - ASSERT_TRUE(layer != NULL); + ASSERT_NE(layer, NULL); retry: - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true) == true); - ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[0]) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); + ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); TDM_UT_ASK_YNR("* Successed to display a frame to a primary layer? (output: %d)", o); - ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); } } @@ -335,19 +335,19 @@ TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowManyFrames) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); layer = ut_tdm_output_get_primary_layer(outputs[o]); - ASSERT_TRUE(layer != NULL); + ASSERT_NE(layer, NULL); retry: - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layer, buffers, 3, true) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 3, true), true); /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { - ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]) == true); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); usleep(40000); /* 40 ms */ next_buffer++; if (next_buffer == 3) @@ -358,8 +358,8 @@ retry: TDM_UT_ASK_YNR("* Successed to display many frames to a primary layer? (output: %d)", o); - ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); } } @@ -381,15 +381,15 @@ TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowOneFrameWithCommitHandler) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); layer = ut_tdm_output_get_primary_layer(outputs[o]); - ASSERT_TRUE(layer != NULL); + ASSERT_NE(layer, NULL); retry: - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true) == true); - ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[0]) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); + ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); bool done = false; @@ -401,8 +401,8 @@ retry: TDM_UT_ASK_YNR("* Successed to display a frame to a primary layer? (output: %d)", o); - ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); } } @@ -414,17 +414,17 @@ TEST_P(TDMBackendBasic, VerifyOverlayLayersShowOneFrame) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); layer = ut_tdm_output_get_primary_layer(outputs[o]); - ASSERT_TRUE(layer != NULL); + ASSERT_NE(layer, NULL); - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layer, buffers, 1, false) == true); - ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[0]) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, false), true); + ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); usleep(40000); /* 40 ms */ retry: @@ -433,23 +433,23 @@ retry: if (tdm_layer_get_output(layers[l], &ret) != outputs[o]) continue; - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); if (ut_tdm_layer_is_primary_layer(layers[l])) continue; if (ut_tdm_layer_is_cursor_layer(layers[l])) continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 1, true) == true); - ASSERT_TRUE(ut_tdm_layer_set_buffer(layers[l], buffers[0]) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true); + ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[0]), true); DestroyBuffers(); } - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); TDM_UT_ASK_YNR("* Successed to display frames to all overlay layers? (output: %d)", o); for (int l = 0; l < layer_count; l++) - ASSERT_TRUE(tdm_layer_unset_buffer(layers[l]) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); } } @@ -461,17 +461,17 @@ TEST_P(TDMBackendBasic, VerifyOverlayLayersShowManyFrames) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); layer = ut_tdm_output_get_primary_layer(outputs[o]); - ASSERT_TRUE(layer != NULL); + ASSERT_NE(layer, NULL); - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layer, buffers, 1, false) == true); - ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[0]) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, false), true); + ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); usleep(40000); /* 40 ms */ for (int l = 0; l < layer_count; l++) { @@ -480,19 +480,19 @@ TEST_P(TDMBackendBasic, VerifyOverlayLayersShowManyFrames) if (tdm_layer_get_output(layers[l], &ret) != outputs[o]) continue; - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); if (ut_tdm_layer_is_primary_layer(layers[l])) continue; if (ut_tdm_layer_is_cursor_layer(layers[l])) continue; retry: - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { - ASSERT_TRUE(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer]) == true); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); usleep(40000); /* 40 ms */ next_buffer++; if (next_buffer == 3) @@ -503,8 +503,8 @@ retry: TDM_UT_ASK_YNR("* Successed to display many frames to a layer? (output: %d, layer: %d)", o, l); - ASSERT_TRUE(tdm_layer_unset_buffer(layers[l]) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); usleep(40000); /* 40 ms */ } } @@ -532,17 +532,17 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblank) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); layer = ut_tdm_output_get_primary_layer(outputs[o]); - ASSERT_TRUE(layer != NULL); + ASSERT_NE(layer, NULL); - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true) == true); - ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[0]) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); + ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); /* start from 1 */ for (int t = 1; t < 10; t++) { @@ -582,17 +582,17 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblankInterval) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); layer = ut_tdm_output_get_primary_layer(outputs[o]); - ASSERT_TRUE(layer != NULL); + ASSERT_NE(layer, NULL); - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true) == true); - ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[0]) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); + ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); /* start from 1 */ for (int t = 1; t < 10; t++) { @@ -603,9 +603,9 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblankInterval) done = false; start = tdm_helper_get_time(); - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -629,17 +629,17 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblankFewTimesInOneVblank) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); layer = ut_tdm_output_get_primary_layer(outputs[o]); - ASSERT_TRUE(layer != NULL); + ASSERT_NE(layer, NULL); - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true) == true); - ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[0]) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); + ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); /* start from 1 */ for (int t = 1; t < 10; t++) { @@ -649,12 +649,12 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblankFewTimesInOneVblank) interval = ut_tdm_output_get_vblank_interval_time(outputs[o]); done1 = done2 = done3 = false; - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done2) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done3) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done3), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done1 || !done2 || !done3) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -714,12 +714,12 @@ TEST_P(TDMBackendBasic, VerifyPPAvaiableSize) int max_w = 0; int max_h = 0; int preferred_align = 0; - ASSERT_TRUE(tdm_display_get_pp_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align) == TDM_ERROR_NONE); - ASSERT_TRUE(min_w != 0); - ASSERT_TRUE(min_h != 0); - ASSERT_TRUE(max_w != 0); - ASSERT_TRUE(max_h != 0); - ASSERT_TRUE(preferred_align != 0); + ASSERT_EQ(tdm_display_get_pp_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE); + ASSERT_NE(min_w, 0); + ASSERT_NE(min_h, 0); + ASSERT_NE(max_w, 0); + ASSERT_NE(max_h, 0); + ASSERT_NE(preferred_align, 0); } TEST_P(TDMBackendBasic, VerifyPPAvaiableFormats) @@ -749,7 +749,7 @@ TEST_P(TDMBackendBasic, VerifyCaptureObject) tdm_error ret; unsigned int has_capability = 0; - ASSERT_TRUE(tdm_output_has_capture_capability(outputs[o], &has_capability) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_has_capture_capability(outputs[o], &has_capability), TDM_ERROR_NONE); if (!has_capability) { TDM_UT_INFO("Capture not supported. (output: %d)", o); continue; @@ -778,12 +778,12 @@ TEST_P(TDMBackendBasic, VerifyCaptureAvaiableSize) int max_w = 0; int max_h = 0; int preferred_align = 0; - ASSERT_TRUE(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align) == TDM_ERROR_NONE); - ASSERT_TRUE(min_w != 0); - ASSERT_TRUE(min_h != 0); - ASSERT_TRUE(max_w != 0); - ASSERT_TRUE(max_h != 0); - ASSERT_TRUE(preferred_align != 0); + ASSERT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE); + ASSERT_NE(min_w, 0); + ASSERT_NE(min_h, 0); + ASSERT_NE(max_w, 0); + ASSERT_NE(max_h, 0); + ASSERT_NE(preferred_align, 0); } TEST_P(TDMBackendBasic, VerifyCaptureAvaiableFormats) @@ -827,32 +827,32 @@ TEST_P(TDMBackendDisplay, VerifyPirmaryLayerFormat) continue; layer = ut_tdm_output_get_primary_layer(outputs[o]); - ASSERT_TRUE(layer != NULL); + ASSERT_NE(layer, NULL); - ASSERT_TRUE(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_get_available_formats(layer, &formats, &format_count) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE); for (int f = 0; f < format_count; f++) { - ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_get_mode(outputs[o], &mode) == TDM_ERROR_NONE); - ASSERT_TRUE(mode != NULL); + ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); + ASSERT_NE(mode, NULL); retry: TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); - ASSERT_TRUE(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers) == true); + ASSERT_EQ(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); /* set buffer & commit for 60 times */ for (int t = 0; t < 60; t++) { tbm_surface_h displaying_buffer; - ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]) == true); + ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); done = false; - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(displaying_buffer == buffers[next_buffer]); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_EQ(displaying_buffer, buffers[next_buffer]); next_buffer++; if (next_buffer == 3) next_buffer = 0; @@ -867,7 +867,7 @@ retry: TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat) { - ASSERT_TRUE(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false) == true); + ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); for (int l = 0; l < layer_count; l++) { tdm_error ret; @@ -884,7 +884,7 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat) layer = layers[l]; output = tdm_layer_get_output(layer, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); if (!ut_tdm_output_is_connected(output)) continue; @@ -893,32 +893,32 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat) if (ut_tdm_layer_is_cursor_layer(layer)) continue; - ASSERT_TRUE(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE); - ASSERT_TRUE(mode != NULL); + ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); + ASSERT_NE(mode, NULL); - ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_get_available_formats(layer, &formats, &format_count) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE); for (int f = 0; f < format_count; f++) { retry: TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); - ASSERT_TRUE(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers) == true); + ASSERT_EQ(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { tbm_surface_h displaying_buffer; - ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]) == true); + ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); done = false; - ASSERT_TRUE(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(displaying_buffer == buffers[next_buffer]); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_EQ(displaying_buffer, buffers[next_buffer]); next_buffer++; if (next_buffer == 3) next_buffer = 0; @@ -929,13 +929,13 @@ retry: DestroyBuffers(); } - ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); } } TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize) { - ASSERT_TRUE(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false) == true); + ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); for (int l = 0; l < layer_count; l++) { tdm_error ret; @@ -952,7 +952,7 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize) layer = layers[l]; output = tdm_layer_get_output(layer, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); if (!ut_tdm_output_is_connected(output)) continue; @@ -961,15 +961,15 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize) if (ut_tdm_layer_is_cursor_layer(layer)) continue; - ASSERT_TRUE(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE); - ASSERT_TRUE(mode != NULL); + ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); + ASSERT_NE(mode, NULL); - ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_get_available_formats(layer, &formats, &format_count) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE); for (int f = 0; f < format_count; f++) { int diffw = mode->hdisplay / (format_count + 2); @@ -978,19 +978,19 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize) int h = mode->vdisplay - diffh * (f + 1); retry: TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); - ASSERT_TRUE(ut_tdm_buffer_create(w, h, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers) == true); + ASSERT_EQ(ut_tdm_buffer_create(w, h, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { tbm_surface_h displaying_buffer; - ASSERT_TRUE(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]) == true); + ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); done = false; - ASSERT_TRUE(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(displaying_buffer == buffers[next_buffer]); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_EQ(displaying_buffer, buffers[next_buffer]); next_buffer++; if (next_buffer == 3) next_buffer = 0; @@ -1002,13 +1002,13 @@ retry: FOURCC_STR(formats[f]), w, h, pipe, l); } - ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); } } TEST_P(TDMBackendDisplay, VerifyOverlayLayerScale) { - ASSERT_TRUE(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false) == true); + ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); for (int l = 0; l < layer_count; l++) { tdm_error ret; @@ -1025,9 +1025,9 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerScale) layer = layers[l]; output = tdm_layer_get_output(layer, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); if (!ut_tdm_output_is_connected(output)) continue; @@ -1040,18 +1040,18 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerScale) continue; } - ASSERT_TRUE(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE); - ASSERT_TRUE(mode != NULL); + ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); + ASSERT_NE(mode, NULL); - ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_get_available_formats(layer, &formats, &format_count) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE); for (int f = 0; f < format_count; f++) { retry: TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); - ASSERT_TRUE(ut_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers) == true); + ASSERT_EQ(ut_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); tdm_info_layer info; memset(&info, 0, sizeof info); @@ -1067,19 +1067,19 @@ retry: info.dst_pos.w = mode->hdisplay; info.dst_pos.h = mode->vdisplay; info.transform = TDM_TRANSFORM_NORMAL; - ASSERT_TRUE(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE); /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { tbm_surface_h displaying_buffer; - ASSERT_TRUE(tdm_layer_set_buffer(layer, buffers[next_buffer]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE); done = false; - ASSERT_TRUE(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(displaying_buffer == buffers[next_buffer]); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_EQ(displaying_buffer, buffers[next_buffer]); next_buffer++; if (next_buffer == 3) next_buffer = 0; @@ -1091,13 +1091,13 @@ retry: FOURCC_STR(formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, pipe, l); } - ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); } } TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition) { - ASSERT_TRUE(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false) == true); + ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); for (int l = 0; l < layer_count; l++) { tdm_error ret; @@ -1114,7 +1114,7 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition) layer = layers[l]; output = tdm_layer_get_output(layer, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); if (!ut_tdm_output_is_connected(output)) continue; @@ -1123,20 +1123,20 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition) if (ut_tdm_layer_is_cursor_layer(layer)) continue; - ASSERT_TRUE(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE); - ASSERT_TRUE(mode != NULL); + ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); + ASSERT_NE(mode, NULL); - ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_get_available_formats(layer, &formats, &format_count) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE); for (int f = 0; f < format_count; f++) { retry: TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); - ASSERT_TRUE(ut_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers) == true); + ASSERT_EQ(ut_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { @@ -1156,16 +1156,16 @@ retry: info.dst_pos.w = TDM_UT_BUFFER_SIZE; info.dst_pos.h = TDM_UT_BUFFER_SIZE; info.transform = TDM_TRANSFORM_NORMAL; - ASSERT_TRUE(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_set_buffer(layer, buffers[next_buffer]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE); done = false; - ASSERT_TRUE(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(displaying_buffer == buffers[next_buffer]); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_EQ(displaying_buffer, buffers[next_buffer]); next_buffer++; if (next_buffer == 3) next_buffer = 0; @@ -1177,13 +1177,13 @@ retry: FOURCC_STR(formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, pipe, l); } - ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); } } TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop) { - ASSERT_TRUE(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false) == true); + ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); for (int l = 0; l < layer_count; l++) { tdm_error ret; @@ -1200,9 +1200,9 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop) layer = layers[l]; output = tdm_layer_get_output(layer, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); if (!ut_tdm_output_is_connected(output)) continue; @@ -1215,18 +1215,18 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop) continue; } - ASSERT_TRUE(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE); - ASSERT_TRUE(mode != NULL); + ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); + ASSERT_NE(mode, NULL); - ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_get_available_formats(layer, &formats, &format_count) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE); for (int f = 0; f < format_count; f++) { retry: TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); - ASSERT_TRUE(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers) == true); + ASSERT_EQ(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); tdm_info_layer info; memset(&info, 0, sizeof info); @@ -1242,19 +1242,19 @@ retry: info.dst_pos.w = info.src_config.pos.w; info.dst_pos.h = info.src_config.pos.h; info.transform = TDM_TRANSFORM_NORMAL; - ASSERT_TRUE(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE); /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { tbm_surface_h displaying_buffer; - ASSERT_TRUE(tdm_layer_set_buffer(layer, buffers[next_buffer]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE); done = false; - ASSERT_TRUE(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(displaying_buffer == buffers[next_buffer]); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_EQ(displaying_buffer, buffers[next_buffer]); next_buffer++; if (next_buffer == 3) next_buffer = 0; @@ -1266,34 +1266,34 @@ retry: FOURCC_STR(formats[f]), pipe, l); } - ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); } } /* should be debugged int emulator kernel */ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOnToOff) { - ASSERT_TRUE(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true) == true); + ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true); for (int o = 0; o < output_count; o++) { if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); } } /* should be debugged int emulator kernel */ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOffToOn) { - ASSERT_TRUE(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true) == true); + ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true); for (int o = 0; o < output_count; o++) { if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); } } @@ -1304,8 +1304,8 @@ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOnBeforeSet) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); } } @@ -1316,8 +1316,8 @@ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffBeforeSet) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_mode_setting(outputs[o]) == true); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); } } @@ -1328,14 +1328,14 @@ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithoutComm if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); tdm_layer *layer = ut_tdm_output_get_primary_layer(outputs[o]); - ASSERT_TRUE(layer != NULL); + ASSERT_NE(layer, NULL); - ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); } } @@ -1346,15 +1346,15 @@ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithCommit) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); tdm_layer *layer = ut_tdm_output_get_primary_layer(outputs[o]); - ASSERT_TRUE(layer != NULL); + ASSERT_NE(layer, NULL); - ASSERT_TRUE(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); } } @@ -1364,7 +1364,7 @@ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsAsync) TEST_P(TDMBackendDisplay, VerifyLayerGetInfo) { - ASSERT_TRUE(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true) == true); + ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true); for (int o = 0; o < output_count; o++) { if (!ut_tdm_output_is_connected(outputs[o])) @@ -1372,10 +1372,10 @@ TEST_P(TDMBackendDisplay, VerifyLayerGetInfo) tdm_info_layer info, temp; tdm_layer *layer = ut_tdm_output_get_primary_layer(outputs[o]); - ASSERT_TRUE(layer != NULL); - ASSERT_TRUE(ut_tdm_layer_fill_info(layer, -1, -1, 0, &info) == true); - ASSERT_TRUE(tdm_layer_get_info(layer, &temp) == TDM_ERROR_NONE); - ASSERT_TRUE(memcmp(&info, &temp, sizeof info) == 0); + ASSERT_NE(layer, NULL); + ASSERT_EQ(ut_tdm_layer_fill_info(layer, -1, -1, 0, &info), true); + ASSERT_EQ(tdm_layer_get_info(layer, &temp), TDM_ERROR_NONE); + ASSERT_EQ(memcmp(&info, &temp, sizeof info), 0); } } diff --git a/utests/src/ut_tdm_backend_pp.cpp b/utests/src/ut_tdm_backend_pp.cpp index dcc7fb7..d1c798c 100644 --- a/utests/src/ut_tdm_backend_pp.cpp +++ b/utests/src/ut_tdm_backend_pp.cpp @@ -76,12 +76,12 @@ void TDMBackendPP::SetUp(void) { TDMBackendDisplay::SetUp(); - ASSERT_TRUE(tdm_display_get_pp_capabilities(dpy, &capabilities) == TDM_ERROR_NONE); - ASSERT_TRUE(capabilities > 0); - ASSERT_TRUE(tdm_display_get_pp_available_formats(dpy, &formats, &format_count) == TDM_ERROR_NONE); - ASSERT_TRUE(formats != NULL); - ASSERT_TRUE(format_count > 0); - ASSERT_TRUE(tdm_display_get_pp_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_display_get_pp_capabilities(dpy, &capabilities), TDM_ERROR_NONE); + ASSERT_GT(capabilities, 0); + ASSERT_EQ(tdm_display_get_pp_available_formats(dpy, &formats, &format_count), TDM_ERROR_NONE); + ASSERT_NE(formats, NULL); + ASSERT_GT(format_count, 0); + ASSERT_EQ(tdm_display_get_pp_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE); ASSERT_TRUE(min_w == -1 || min_w > 0); ASSERT_TRUE(min_h == -1 || min_h > 0); ASSERT_TRUE(max_w == -1 || max_w > 0); @@ -216,18 +216,18 @@ TEST_P(TDMBackendPP, PPDispalyGetAvaiableFormatsNullObject) const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; if (ut_tdm_display_has_pp_capability(dpy)) - ASSERT_TRUE(tdm_display_get_pp_available_formats(NULL, &formats, &count) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_display_get_pp_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER); else - ASSERT_TRUE(tdm_display_get_pp_available_formats(NULL, &formats, &count) == TDM_ERROR_NO_CAPABILITY); - ASSERT_TRUE(formats == (const tbm_format *)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(count == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_pp_available_formats(NULL, &formats, &count), TDM_ERROR_NO_CAPABILITY); + ASSERT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE); + ASSERT_EQ(count, TDM_UT_INVALID_VALUE); } TEST_P(TDMBackendPP, PPDispalyGetAvaiableFormatsNullOther) { if (ut_tdm_display_has_pp_capability(dpy)) { - ASSERT_TRUE(PreparePP() == true); - ASSERT_TRUE(tdm_display_get_pp_available_formats(pp, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(PreparePP(), true); + ASSERT_EQ(tdm_display_get_pp_available_formats(pp, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } } @@ -239,21 +239,21 @@ TEST_P(TDMBackendPP, PPDispalyGetAvaiableSizeNullObject) int max_h = TDM_UT_INVALID_VALUE; int preferred_align = TDM_UT_INVALID_VALUE; if (ut_tdm_display_has_pp_capability(dpy)) - ASSERT_TRUE(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER); else - ASSERT_TRUE(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align) == TDM_ERROR_NO_CAPABILITY); - ASSERT_TRUE(min_w == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(min_h == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(max_w == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(max_h == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(preferred_align == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NO_CAPABILITY); + ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE); + ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE); + ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE); + ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE); + ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE); } TEST_P(TDMBackendPP, PPDispalyGetAvaiableSizeNullOther) { if (ut_tdm_display_has_pp_capability(dpy)) { - ASSERT_TRUE(PreparePP() == true); - ASSERT_TRUE(tdm_display_get_pp_available_size(pp, NULL, NULL, NULL, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(PreparePP(), true); + ASSERT_EQ(tdm_display_get_pp_available_size(pp, NULL, NULL, NULL, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } } @@ -261,7 +261,7 @@ TEST_P(TDMBackendPP, PPDestroy) { TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); - ASSERT_TRUE(PreparePP() == true); + ASSERT_EQ(PreparePP(), true); tdm_pp_destroy(pp); pp = NULL; } @@ -284,15 +284,15 @@ TEST_P(TDMBackendPP, PPSetInfoNullObject) tdm_info_pp info; memset(&info, 0, sizeof info); - ASSERT_TRUE(tdm_pp_set_info(NULL, &info) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_pp_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendPP, PPSetInfoNullOther) { TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); - ASSERT_TRUE(PreparePP() == true); - ASSERT_TRUE(tdm_pp_set_info(pp, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(PreparePP(), true); + ASSERT_EQ(tdm_pp_set_info(pp, NULL), TDM_ERROR_INVALID_PARAMETER); } static void @@ -307,38 +307,38 @@ TEST_P(TDMBackendPP, PPSetDoneHandler) { TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); - ASSERT_TRUE(PreparePP() == true); - ASSERT_TRUE(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(PreparePP(), true); + ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, NULL), TDM_ERROR_NONE); } TEST_P(TDMBackendPP, PPSetDoneHandlerNullObject) { TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); - ASSERT_TRUE(tdm_pp_set_done_handler(NULL, _ut_tdm_pp_done_cb, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_pp_set_done_handler(NULL, _ut_tdm_pp_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendPP, PPSetDoneHandlerNullOther) { TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); - ASSERT_TRUE(PreparePP() == true); - ASSERT_TRUE(tdm_pp_set_done_handler(pp, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(PreparePP(), true); + ASSERT_EQ(tdm_pp_set_done_handler(pp, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendPP, PPAttach) { TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); - ASSERT_TRUE(PreparePP() == true); + ASSERT_EQ(PreparePP(), true); for (int f = 0; f < format_count; f++) { - ASSERT_TRUE(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_TRANSFORM_NORMAL) == true); + TDM_TRANSFORM_NORMAL), true); for (int b = 0; b < 3; b++) - ASSERT_TRUE(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); DestroyBuffers(); } @@ -351,32 +351,32 @@ TEST_P(TDMBackendPP, PPAttachNullObject) tbm_surface_h srcbuf = (tbm_surface_h)TDM_UT_BUFFER_SIZE; tbm_surface_h dstbuf = (tbm_surface_h)TDM_UT_BUFFER_SIZE; - ASSERT_TRUE(tdm_pp_attach(NULL, srcbuf, dstbuf) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_pp_attach(NULL, srcbuf, dstbuf), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendPP, PPAttachNullOther) { TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); - ASSERT_TRUE(PreparePP() == true); + ASSERT_EQ(PreparePP(), true); - ASSERT_TRUE(tdm_pp_attach(pp, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_pp_attach(pp, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendPP, PPCommit) { TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); - ASSERT_TRUE(PreparePP() == true); + ASSERT_EQ(PreparePP(), true); - ASSERT_TRUE(tdm_pp_commit(pp) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); } TEST_P(TDMBackendPP, PPCommitNullOBject) { TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); - ASSERT_TRUE(tdm_pp_commit(NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_pp_commit(NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendPP, PPNoScaleNoTransformNoCSC) @@ -389,22 +389,22 @@ TEST_P(TDMBackendPP, PPNoScaleNoTransformNoCSC) TDM_INFO("---- format(%c%c%c%c)", FOURCC_STR(formats[0])); - ASSERT_TRUE(PreparePP() == true); + ASSERT_EQ(PreparePP(), true); - ASSERT_TRUE(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, formats[0], + ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, formats[0], TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, formats[0], - TDM_TRANSFORM_NORMAL) == true); + TDM_TRANSFORM_NORMAL), true); - ASSERT_TRUE(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) { done = false; - ASSERT_TRUE(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_pp_commit(pp) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); while (!done) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); DumpBuffers(b, temp); } @@ -417,7 +417,7 @@ TEST_P(TDMBackendPP, PPScaleTransformCSC) { TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); - ASSERT_TRUE(PreparePP() == true); + ASSERT_EQ(PreparePP(), true); bool done; tbm_format format1, format2; @@ -430,20 +430,20 @@ TEST_P(TDMBackendPP, PPScaleTransformCSC) TDM_INFO("format(%c%c%c%c) ------> format(%c%c%c%c)", FOURCC_STR(format1), FOURCC_STR(format2)); - ASSERT_TRUE(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, format1, + ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, format1, TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, format2, - TDM_TRANSFORM_NORMAL) == true); + TDM_TRANSFORM_NORMAL), true); - ASSERT_TRUE(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) { done = false; - ASSERT_TRUE(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_pp_commit(pp) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); while (!done) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); DumpBuffers(b, NULL); } @@ -464,25 +464,25 @@ TEST_P(TDMBackendPP, DISABLED_PPAttachFewTimesInOneCommit) { TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); - ASSERT_TRUE(PreparePP() == true); + ASSERT_EQ(PreparePP(), true); int done = 0; int f = 0; char temp[256]; snprintf(temp, sizeof temp, "%c%c%c%c", FOURCC_STR(formats[f])); - ASSERT_TRUE(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_TRANSFORM_NORMAL) == true); + TDM_TRANSFORM_NORMAL), true); - ASSERT_TRUE(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb2, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb2, &done), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) - ASSERT_TRUE(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_pp_commit(pp) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); while (done != 3) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) DumpBuffers(b, temp); @@ -494,17 +494,17 @@ TEST_P(TDMBackendPP, PPDestroyWithoutCommit) { TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); - ASSERT_TRUE(PreparePP() == true); + ASSERT_EQ(PreparePP(), true); int f = 0; - ASSERT_TRUE(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_TRANSFORM_NORMAL) == true); + TDM_TRANSFORM_NORMAL), true); - ASSERT_TRUE(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb2, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb2, NULL), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) - ASSERT_TRUE(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); tdm_pp_destroy(pp); pp = NULL; @@ -516,19 +516,19 @@ TEST_P(TDMBackendPP, PPDestroyBeforeDone) { TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); - ASSERT_TRUE(PreparePP() == true); + ASSERT_EQ(PreparePP(), true); int f = 0; - ASSERT_TRUE(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_TRANSFORM_NORMAL) == true); + TDM_TRANSFORM_NORMAL), true); - ASSERT_TRUE(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb2, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb2, NULL), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) - ASSERT_TRUE(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_pp_commit(pp) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); tdm_pp_destroy(pp); pp = NULL; diff --git a/utests/src/ut_tdm_buffer.cpp b/utests/src/ut_tdm_buffer.cpp index 97fcf31..c2df7ee 100644 --- a/utests/src/ut_tdm_buffer.cpp +++ b/utests/src/ut_tdm_buffer.cpp @@ -48,7 +48,7 @@ void TDMBuffer::SetUp(void) TDMDisplay::SetUp(); buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888); - ASSERT_TRUE(buffer != NULL); + ASSERT_NE(buffer, NULL); } void TDMBuffer::TearDown(void) @@ -89,13 +89,13 @@ failed: TEST_P(TDMBuffer, BufferRefBackend) { - ASSERT_TRUE(tdm_buffer_ref_backend(buffer) == buffer); + ASSERT_EQ(tdm_buffer_ref_backend(buffer), buffer); tdm_buffer_unref_backend(buffer); } TEST_P(TDMBuffer, BufferRefBackendNullOBject) { - ASSERT_TRUE(tdm_buffer_ref_backend(NULL) == NULL); + ASSERT_EQ(tdm_buffer_ref_backend(NULL), NULL); } TEST_P(TDMBuffer, BufferUnrefBackend) @@ -119,46 +119,46 @@ _ut_tdm_buffer_destroy_cb(tbm_surface_h buffer, void *user_data) TEST_P(TDMBuffer, BufferAddDestroyHandler) { bool done = false; - ASSERT_TRUE(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE); tbm_surface_destroy(buffer); buffer = NULL; - ASSERT_TRUE(done == true); + ASSERT_EQ(done, true); } TEST_P(TDMBuffer, BufferAddDestroyHandlerTwice) { - ASSERT_TRUE(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, NULL) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, NULL) == TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, NULL), TDM_ERROR_BAD_REQUEST); } TEST_P(TDMBuffer, BufferAddDestroyHandlerNullObject) { - ASSERT_TRUE(tdm_buffer_add_destroy_handler(NULL, _ut_tdm_buffer_destroy_cb, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_buffer_add_destroy_handler(NULL, _ut_tdm_buffer_destroy_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBuffer, BufferAddDestroyHandlerNullOther) { - ASSERT_TRUE(tdm_buffer_add_destroy_handler(buffer, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBuffer, BufferRemoveDestroyHandler) { bool done = false; - ASSERT_TRUE(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE); tdm_buffer_remove_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, &done); tbm_surface_destroy(buffer); buffer = NULL; - ASSERT_TRUE(done == false); + ASSERT_EQ(done, false); } TEST_P(TDMBuffer, BufferRemoveDestroyHandlerDifferentData) { bool done = false; - ASSERT_TRUE(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE); tdm_buffer_remove_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, NULL); tbm_surface_destroy(buffer); buffer = NULL; - ASSERT_TRUE(done == true); + ASSERT_EQ(done, true); } TEST_P(TDMBuffer, BufferRemoveDestroyHandlerNullObject) @@ -182,51 +182,51 @@ _ut_tdm_buffer_release_cb(tbm_surface_h buffer, void *user_data) TEST_P(TDMBuffer, BufferAddReleaseHandler) { bool done = false; - ASSERT_TRUE(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); - ASSERT_TRUE(done == false); + ASSERT_EQ(done, false); tdm_buffer_unref_backend(buffer); - ASSERT_TRUE(done == true); + ASSERT_EQ(done, true); } TEST_P(TDMBuffer, BufferAddReleaseHandlerTwice) { - ASSERT_TRUE(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, NULL) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, NULL) == TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, NULL), TDM_ERROR_BAD_REQUEST); } TEST_P(TDMBuffer, BufferAddReleaseHandlerNullObject) { bool done = false; - ASSERT_TRUE(tdm_buffer_add_release_handler(NULL, _ut_tdm_buffer_release_cb, &done) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(done == false); + ASSERT_EQ(tdm_buffer_add_release_handler(NULL, _ut_tdm_buffer_release_cb, &done), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(done, false); } TEST_P(TDMBuffer, BufferAddReleaseHandlerNullOther) { - ASSERT_TRUE(tdm_buffer_add_release_handler(buffer, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBuffer, BufferRemoveReleaseHandler) { bool done = false; - ASSERT_TRUE(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); - ASSERT_TRUE(done == false); + ASSERT_EQ(done, false); tdm_buffer_remove_release_handler(buffer, _ut_tdm_buffer_release_cb, &done); tdm_buffer_unref_backend(buffer); - ASSERT_TRUE(done == false); + ASSERT_EQ(done, false); } TEST_P(TDMBuffer, BufferRemoveReleaseHandlerDifferentData) { bool done = false; - ASSERT_TRUE(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); - ASSERT_TRUE(done == false); + ASSERT_EQ(done, false); tdm_buffer_remove_release_handler(buffer, _ut_tdm_buffer_release_cb, NULL); tdm_buffer_unref_backend(buffer); - ASSERT_TRUE(done == true); + ASSERT_EQ(done, true); } static void @@ -241,36 +241,36 @@ _ut_tdm_buffer_release_cb2(tbm_surface_h buffer, void *user_data) TEST_P(TDMBuffer, BufferRemoveReleaseHandlerInHandler) { bool done = false; - ASSERT_TRUE(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb2, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); - ASSERT_TRUE(done == false); + ASSERT_EQ(done, false); tdm_buffer_unref_backend(buffer); - ASSERT_TRUE(done == true); + ASSERT_EQ(done, true); done = false; - ASSERT_TRUE(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb2, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); - ASSERT_TRUE(done == false); + ASSERT_EQ(done, false); tdm_buffer_unref_backend(buffer); - ASSERT_TRUE(done == true); + ASSERT_EQ(done, true); done = false; - ASSERT_TRUE(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb2, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); - ASSERT_TRUE(done == false); + ASSERT_EQ(done, false); tdm_buffer_unref_backend(buffer); - ASSERT_TRUE(done == true); + ASSERT_EQ(done, true); } TEST_P(TDMBuffer, BufferRemoveReleaseHandlerNullObject) { bool done = false; - ASSERT_TRUE(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); - ASSERT_TRUE(done == false); + ASSERT_EQ(done, false); tdm_buffer_remove_release_handler(NULL, _ut_tdm_buffer_release_cb, &done); tdm_buffer_unref_backend(buffer); - ASSERT_TRUE(done == true); + ASSERT_EQ(done, true); } TEST_P(TDMBuffer, BufferRemoveReleaseHandlerNullOther) diff --git a/utests/src/ut_tdm_client.cpp b/utests/src/ut_tdm_client.cpp index 2fd8db0..3df66c8 100644 --- a/utests/src/ut_tdm_client.cpp +++ b/utests/src/ut_tdm_client.cpp @@ -94,7 +94,7 @@ void TDMClient::ServerFork(void) return; server_pid = _ut_tdm_client_server_fork(pipe_parent, pipe_child); - ASSERT_TRUE(server_pid > 0); + ASSERT_GT(server_pid, 0); } void TDMClient::ServerKill(void) @@ -138,7 +138,7 @@ void TDMClient::SetUp(void) void TDMClient::TearDown(void) { - ASSERT_TRUE(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON) == true); + ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); if (vblank) tdm_client_vblank_destroy(vblank); @@ -370,14 +370,14 @@ TEST_P(TDMClient, ClientCreate) tdm_error ret; client = tdm_client_create(&ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(client != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(client, NULL); } TEST_P(TDMClient, ClientCreateNullOther) { client = tdm_client_create(NULL); - ASSERT_TRUE(client != NULL); + ASSERT_NE(client, NULL); } TEST_P(TDMClient, ClientDestroy) @@ -385,8 +385,8 @@ TEST_P(TDMClient, ClientDestroy) tdm_error ret; client = tdm_client_create(&ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(client != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(client, NULL); tdm_client_destroy(client); client = NULL; @@ -402,37 +402,37 @@ TEST_P(TDMClient, ClientGetFd) { int fd = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(PrepareClient() == true); + ASSERT_EQ(PrepareClient(), true); - ASSERT_TRUE(tdm_client_get_fd(client, &fd) == TDM_ERROR_NONE); - ASSERT_TRUE(fd >= 0); + ASSERT_EQ(tdm_client_get_fd(client, &fd), TDM_ERROR_NONE); + ASSERT_GE(fd, 0); } TEST_P(TDMClient, ClientGetFdNullObject) { int fd = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_client_get_fd(NULL, &fd) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(fd == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_client_get_fd(NULL, &fd), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(fd, TDM_UT_INVALID_VALUE); } TEST_P(TDMClient, ClientGetFdNullOther) { - ASSERT_TRUE(PrepareClient() == true); + ASSERT_EQ(PrepareClient(), true); - ASSERT_TRUE(tdm_client_get_fd(client, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_client_get_fd(client, NULL), TDM_ERROR_INVALID_PARAMETER); } /* tdm_client_handle_events_timeout */ TEST_P(TDMClient, DISABLED_ClientHandleEvent) { - ASSERT_TRUE(PrepareClient() == true); + ASSERT_EQ(PrepareClient(), true); -// ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); +// ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientHandleEventNullObject) { - ASSERT_TRUE(tdm_client_handle_events_timeout(NULL, 3000) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_client_handle_events_timeout(NULL, 3000), TDM_ERROR_INVALID_PARAMETER); } static void @@ -448,13 +448,13 @@ TEST_P(TDMClient, ClientWaitVblank) { bool done = false; - ASSERT_TRUE(PrepareClient() == true); + ASSERT_EQ(PrepareClient(), true); - ASSERT_TRUE(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _ut_tdm_client_vblank_cb, &done) == TDM_ERROR_NONE); - ASSERT_TRUE(done == false); + ASSERT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _ut_tdm_client_vblank_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(done, false); while (!done) - ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); } /* tdm_client_get_output */ @@ -462,44 +462,44 @@ TEST_P(TDMClient, ClientGetOutput) { tdm_error ret; - ASSERT_TRUE(PrepareClient() == true); + ASSERT_EQ(PrepareClient(), true); output = tdm_client_get_output(client, NULL, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(output, NULL); } TEST_P(TDMClient, ClientGetOutputPrimary) { tdm_error ret; - ASSERT_TRUE(PrepareClient() == true); + ASSERT_EQ(PrepareClient(), true); output = tdm_client_get_output(client, (char*)"primary", &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(output, NULL); } TEST_P(TDMClient, ClientGetOutputDefault) { tdm_error ret; - ASSERT_TRUE(PrepareClient() == true); + ASSERT_EQ(PrepareClient(), true); output = tdm_client_get_output(client, (char*)"default", &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(output, NULL); } TEST_P(TDMClient, ClientGetOutputInvalidName) { tdm_error ret; - ASSERT_TRUE(PrepareClient() == true); + ASSERT_EQ(PrepareClient(), true); output = tdm_client_get_output(client, (char*)"invalid", &ret); - ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(output == NULL); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(output, NULL); } TEST_P(TDMClient, ClientGetOutputNullObject) @@ -507,16 +507,16 @@ TEST_P(TDMClient, ClientGetOutputNullObject) tdm_error ret; output = tdm_client_get_output(NULL, NULL, &ret); - ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(output == NULL); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(output, NULL); } TEST_P(TDMClient, ClientGetOutputNullOther) { - ASSERT_TRUE(PrepareClient() == true); + ASSERT_EQ(PrepareClient(), true); output = tdm_client_get_output(client, NULL, NULL); - ASSERT_TRUE(output != NULL); + ASSERT_NE(output, NULL); } static void @@ -543,48 +543,48 @@ TEST_P(TDMClient, ClientOutputAddChangeHandler) bool done = false; tdm_output_dpms dpms; - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); - ASSERT_TRUE(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, &done) == TDM_ERROR_NONE); - ASSERT_TRUE(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF) == true); + ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); while (!done) - ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_client_output_get_dpms(output, &dpms) == TDM_ERROR_NONE); - ASSERT_TRUE(dpms == TDM_OUTPUT_DPMS_OFF); + ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); + ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF); } TEST_P(TDMClient, ClientOutputAddChangeHandlerTwice) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); - ASSERT_TRUE(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL) == TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_BAD_REQUEST); } TEST_P(TDMClient, ClientOutputAddChangeHandlerNullObject) { - ASSERT_TRUE(tdm_client_output_add_change_handler(NULL, _ut_tdm_client_output_change_dpms_cb, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_client_output_add_change_handler(NULL, _ut_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMClient, ClientOutputAddChangeHandlerNullOther) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); - ASSERT_TRUE(tdm_client_output_add_change_handler(output, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_client_output_add_change_handler(output, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } /* tdm_client_output_remove_change_handler */ TEST_P(TDMClient, ClientOutputRemoveChangeHandler) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); - ASSERT_TRUE(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE); tdm_client_output_remove_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL); } @@ -592,10 +592,10 @@ TEST_P(TDMClient, ClientOutputRemoveChangeHandlerDifferentData) { bool done = (bool)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); - ASSERT_TRUE(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE); tdm_client_output_remove_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL); } @@ -618,15 +618,15 @@ TEST_P(TDMClient, ClientOutputRemoveChangeHandlerInHandler) { tdm_output_dpms dpms = TDM_OUTPUT_DPMS_ON; - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); - ASSERT_TRUE(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb2, NULL) == TDM_ERROR_NONE); - ASSERT_TRUE(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF) == true); - ASSERT_TRUE(tdm_client_output_get_dpms(output, &dpms) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb2, NULL), TDM_ERROR_NONE); + ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); + ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); while (dpms != TDM_OUTPUT_DPMS_OFF) { - ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_client_output_get_dpms(output, &dpms) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); } } @@ -637,8 +637,8 @@ TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullObject) TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullOther) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); tdm_client_output_remove_change_handler(output, NULL, NULL); } @@ -648,27 +648,27 @@ TEST_P(TDMClient, ClientOutputGetRefreshRate) { unsigned int refresh = 0; - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); - ASSERT_TRUE(tdm_client_output_get_refresh_rate(output, &refresh) == TDM_ERROR_NONE); - ASSERT_TRUE(refresh > 0); + ASSERT_EQ(tdm_client_output_get_refresh_rate(output, &refresh), TDM_ERROR_NONE); + ASSERT_GT(refresh, 0); } TEST_P(TDMClient, ClientOutputGetRefreshRateNullObject) { unsigned int refresh = (unsigned int)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_client_output_get_refresh_rate(NULL, &refresh) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(refresh == (unsigned int)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_client_output_get_refresh_rate(NULL, &refresh), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(refresh, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMClient, ClientOutputGetRefreshRateNullOther) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); - ASSERT_TRUE(tdm_client_output_get_refresh_rate(output, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_client_output_get_refresh_rate(output, NULL), TDM_ERROR_INVALID_PARAMETER); } /* tdm_client_output_get_refresh_rate */ @@ -676,27 +676,27 @@ TEST_P(TDMClient, ClientOutputGetConnStatus) { tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); - ASSERT_TRUE(tdm_client_output_get_conn_status(output, &status) == TDM_ERROR_NONE); - ASSERT_TRUE(status != (tdm_output_conn_status)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_client_output_get_conn_status(output, &status), TDM_ERROR_NONE); + ASSERT_NE(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE); } TEST_P(TDMClient, ClientOutputGetConnStatusNullObject) { tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_client_output_get_conn_status(NULL, &status) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(status == (tdm_output_conn_status)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_client_output_get_conn_status(NULL, &status), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE); } TEST_P(TDMClient, ClientOutputGetConnStatusNullOther) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); - ASSERT_TRUE(tdm_client_output_get_conn_status(output, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_client_output_get_conn_status(output, NULL), TDM_ERROR_INVALID_PARAMETER); } /* tdm_client_output_get_dpms */ @@ -704,27 +704,27 @@ TEST_P(TDMClient, ClientOutputGetDpms) { tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); - ASSERT_TRUE(tdm_client_output_get_dpms(output, &dpms) == TDM_ERROR_NONE); - ASSERT_TRUE(dpms != (tdm_output_dpms)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); + ASSERT_NE(dpms, (tdm_output_dpms)TDM_UT_INVALID_VALUE); } TEST_P(TDMClient, ClientOutputGetDpmsNullObject) { tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_client_output_get_dpms(NULL, &dpms) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(dpms == (tdm_output_dpms)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_client_output_get_dpms(NULL, &dpms), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(dpms, (tdm_output_dpms)TDM_UT_INVALID_VALUE); } TEST_P(TDMClient, ClientOutputGetDpmsNullOther) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); - ASSERT_TRUE(tdm_client_output_get_dpms(output, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_client_output_get_dpms(output, NULL), TDM_ERROR_INVALID_PARAMETER); } /* tdm_client_output_create_vblank */ @@ -732,12 +732,12 @@ TEST_P(TDMClient, ClientOutputCreateVblank) { tdm_error ret; - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); vblank = tdm_client_output_create_vblank(output, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(vblank != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(vblank, NULL); } TEST_P(TDMClient, ClientOutputCreateVblankNullObject) @@ -745,17 +745,17 @@ TEST_P(TDMClient, ClientOutputCreateVblankNullObject) tdm_error ret; vblank = tdm_client_output_create_vblank(NULL, &ret); - ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(vblank == NULL); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(vblank, NULL); } TEST_P(TDMClient, ClientOutputCreateVblankNullOther) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); vblank = tdm_client_output_create_vblank(output, NULL); - ASSERT_TRUE(vblank != NULL); + ASSERT_NE(vblank, NULL); } /* tdm_client_vblank_destroy */ @@ -763,12 +763,12 @@ TEST_P(TDMClient, ClientVblankDestroy) { tdm_error ret; - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); vblank = tdm_client_output_create_vblank(output, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(vblank != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(vblank, NULL); tdm_client_vblank_destroy(vblank); vblank = NULL; @@ -782,126 +782,126 @@ TEST_P(TDMClient, ClientVblankDestroyNullObject) /* tdm_client_vblank_set_name */ TEST_P(TDMClient, ClientVblankSetName) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); - ASSERT_TRUE(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetNameTwice) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); - ASSERT_TRUE(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetNameNullObject) { - ASSERT_TRUE(tdm_client_vblank_set_name(NULL, TDM_UT_VBLANK_NAME) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_client_vblank_set_name(NULL, TDM_UT_VBLANK_NAME), TDM_ERROR_INVALID_PARAMETER); } /* tdm_client_vblank_set_sync */ TEST_P(TDMClient, ClientVblankSetSync) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); - ASSERT_TRUE(tdm_client_vblank_set_sync(vblank, 1) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetSyncTwice) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); - ASSERT_TRUE(tdm_client_vblank_set_sync(vblank, 1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_client_vblank_set_sync(vblank, 1) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetSyncNullObject) { - ASSERT_TRUE(tdm_client_vblank_set_sync(NULL, 1) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_client_vblank_set_sync(NULL, 1), TDM_ERROR_INVALID_PARAMETER); } /* tdm_client_vblank_set_fps */ TEST_P(TDMClient, ClientVblankSetFps) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); - ASSERT_TRUE(tdm_client_vblank_set_fps(vblank, 30) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetFpsTwice) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); - ASSERT_TRUE(tdm_client_vblank_set_fps(vblank, 30) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_client_vblank_set_fps(vblank, 30) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetFpsNullObject) { - ASSERT_TRUE(tdm_client_vblank_set_fps(NULL, 30) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_client_vblank_set_fps(NULL, 30), TDM_ERROR_INVALID_PARAMETER); } /* tdm_client_vblank_set_offset */ TEST_P(TDMClient, ClientVblankSetOffset) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); - ASSERT_TRUE(tdm_client_vblank_set_offset(vblank, 10) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetOffsetTwice) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); - ASSERT_TRUE(tdm_client_vblank_set_offset(vblank, 10) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_client_vblank_set_offset(vblank, 10) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetOffsetNullObject) { - ASSERT_TRUE(tdm_client_vblank_set_offset(NULL, 10) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_client_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER); } /* tdm_client_vblank_set_enable_fake */ TEST_P(TDMClient, ClientVblankSetEnableFake) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); - ASSERT_TRUE(tdm_client_vblank_set_enable_fake(vblank, 1) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetEnableFakeTwice) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); - ASSERT_TRUE(tdm_client_vblank_set_enable_fake(vblank, 1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_client_vblank_set_enable_fake(vblank, 1) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetEnableFakeNullObject) { - ASSERT_TRUE(tdm_client_vblank_set_enable_fake(NULL, 1) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_client_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER); } static void @@ -922,75 +922,75 @@ TEST_P(TDMClient, ClientVblankWait) { bool done; - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); done = false; - ASSERT_TRUE(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done) - ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) < (vrefresh_interval + vrefresh_interval)); + ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval)); } TEST_P(TDMClient, ClientVblankWaitFewTime) { bool done1, done2, done3; - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); done1 = done2 = done3 = false; - ASSERT_TRUE(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done2) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done3) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done3), TDM_ERROR_NONE); start = tdm_helper_get_time(); while(!done1 || !done2 || !done3) - ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) < (vrefresh_interval + vrefresh_interval)); + ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval)); } TEST_P(TDMClient, ClientVblankWaitInterval0) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); - ASSERT_TRUE(tdm_client_vblank_wait(vblank, 0, _ut_tdm_client_vblank_cb2, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 0, _ut_tdm_client_vblank_cb2, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMClient, ClientVblankWaitInterval) { bool done; - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); /* start from 1 */ for (int t = 1; t < 10; t++) { done = false; - ASSERT_TRUE(tdm_client_vblank_wait(vblank, t, _ut_tdm_client_vblank_cb2, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, t, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done) - ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) > (vrefresh_interval * (t - 1))); - ASSERT_TRUE((end - start) < (vrefresh_interval * t + vrefresh_interval)); + ASSERT_GT((end - start), (vrefresh_interval * (t - 1))); + ASSERT_LT((end - start), (vrefresh_interval * t + vrefresh_interval)); } } @@ -1009,51 +1009,51 @@ _ut_tdm_client_vblank_cb3(tdm_client_vblank *vblank, TEST_P(TDMClient, ClientVblankWaitSeq) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); for (int t = 0; t < 10; t++) { unsigned int cur_seq = 0, temp = 0; - ASSERT_TRUE(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb3, &cur_seq) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); start = tdm_helper_get_time(); - ASSERT_TRUE(tdm_client_vblank_wait_seq(vblank, cur_seq + 1, _ut_tdm_client_vblank_cb3, &temp) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + 1, _ut_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE); while (temp == 0) - ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) < (vrefresh_interval + vrefresh_interval)); + ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval)); } } TEST_P(TDMClient, ClientVblankWaitSeqInterval) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); /* start from 1 */ for (int t = 1; t < 10; t++) { unsigned int cur_seq = 0, temp = 0; - ASSERT_TRUE(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb3, &cur_seq) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); start = tdm_helper_get_time(); - ASSERT_TRUE(tdm_client_vblank_wait_seq(vblank, cur_seq + t, _ut_tdm_client_vblank_cb3, &temp) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + t, _ut_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE); while (temp == 0) - ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) > (vrefresh_interval * (t - 1))); - ASSERT_TRUE((end - start) < (vrefresh_interval * t + vrefresh_interval)); + ASSERT_GT((end - start), (vrefresh_interval * (t - 1))); + ASSERT_LT((end - start), (vrefresh_interval * t + vrefresh_interval)); } } @@ -1061,32 +1061,32 @@ TEST_P(TDMClient, ClientVblankWaitNullObject) { unsigned int cur_seq = 0; - ASSERT_TRUE(tdm_client_vblank_wait(NULL, 1, _ut_tdm_client_vblank_cb3, &cur_seq) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_client_vblank_wait(NULL, 1, _ut_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMClient, ClientVblankWaitNullOther) { - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); - ASSERT_TRUE(tdm_client_vblank_wait(vblank, 1, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMClient, ClientVblankWaitDpmsOff) { tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); - ASSERT_TRUE(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF) == true); + ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); while (dpms != TDM_OUTPUT_DPMS_OFF) - ASSERT_TRUE(tdm_client_output_get_dpms(output, &dpms) == TDM_ERROR_NONE); - ASSERT_TRUE(dpms == TDM_OUTPUT_DPMS_OFF); + ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); + ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF); - ASSERT_TRUE(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, NULL) == TDM_ERROR_DPMS_OFF); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, NULL), TDM_ERROR_DPMS_OFF); } TEST_P(TDMClient, ClientVblankWaitSetEnableFakeDpmsOff) @@ -1094,44 +1094,44 @@ TEST_P(TDMClient, ClientVblankWaitSetEnableFakeDpmsOff) tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE; bool done; - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); - ASSERT_TRUE(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF) == true); + ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); while (dpms != TDM_OUTPUT_DPMS_OFF) - ASSERT_TRUE(tdm_client_output_get_dpms(output, &dpms) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_client_vblank_set_enable_fake(vblank, 1) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE); done = false; - ASSERT_TRUE(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); while (!done) - ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankWaitSetOffset) { bool done; - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); - ASSERT_TRUE(tdm_client_vblank_set_offset(vblank, 100) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 100), TDM_ERROR_NONE); done = false; - ASSERT_TRUE(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done) - ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) > (0.1)); - ASSERT_TRUE((end - start) < (vrefresh_interval + vrefresh_interval + 0.1)); + ASSERT_GT((end - start), (0.1)); + ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval + 0.1)); } TEST_P(TDMClient, ClientVblankWaitSetFps) @@ -1140,24 +1140,24 @@ TEST_P(TDMClient, ClientVblankWaitSetFps) double interval; unsigned int fps = 10; - ASSERT_TRUE(PrepareClient() == true); - ASSERT_TRUE(PrepareOutput() == true); - ASSERT_TRUE(PrepareVblank() == true); + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); - ASSERT_TRUE(tdm_client_vblank_set_fps(vblank, fps) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_set_fps(vblank, fps), TDM_ERROR_NONE); interval = 1.0 / (double)fps; done = false; - ASSERT_TRUE(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done) - ASSERT_TRUE(tdm_client_handle_events_timeout(client, 3000) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) > (interval - vrefresh_interval)); - ASSERT_TRUE((end - start) < (interval + vrefresh_interval)); + ASSERT_GT((end - start), (interval - vrefresh_interval)); + ASSERT_LT((end - start), (interval + vrefresh_interval)); } #if 0 @@ -1172,16 +1172,16 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps) unsigned int global_fps = 5; double start, end, interval; - ASSERT_TRUE(TestPrepareOutput() == true); - ASSERT_TRUE(TestCreateVblanks3() == true); - ASSERT_TRUE(vblank_count == 3); + ASSERT_EQ(TestPrepareOutput(), true); + ASSERT_EQ(TestCreateVblanks3(), true); + ASSERT_EQ(vblank_count, 3); - ASSERT_TRUE(tdm_vblank_get_fps(vblanks[0], &fps) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE); ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE); vrefresh_interval = 1.0 / (double)fps; for (int v = 0; v < 3; v++) - ASSERT_TRUE(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)), TDM_ERROR_NONE); /* enable test */ tdm_vblank_enable_global_fps(1, global_fps); @@ -1189,37 +1189,37 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps) for (int v = 0; v < 3; v++) { cur_seq[v] = 0; - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); } start = tdm_helper_get_time(); while (cur_seq[0] == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); - ASSERT_TRUE(cur_seq[1] != 0); - ASSERT_TRUE(cur_seq[2] != 0); + ASSERT_NE(cur_seq[1], 0); + ASSERT_NE(cur_seq[2], 0); /* "+- vrefresh_interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) > (interval - vrefresh_interval)); - ASSERT_TRUE((end - start) < (interval + vrefresh_interval)); + ASSERT_GT((end - start), (interval - vrefresh_interval)); + ASSERT_LT((end - start), (interval + vrefresh_interval)); /* disable test */ tdm_vblank_enable_global_fps(0, 0); for (int v = 0; v < 3; v++) { cur_seq[v] = 0; - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); } while (cur_seq[0] == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); - ASSERT_TRUE(cur_seq[1] == 0); - ASSERT_TRUE(cur_seq[2] == 0); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(cur_seq[1], 0); + ASSERT_EQ(cur_seq[2], 0); while (cur_seq[1] == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); - ASSERT_TRUE(cur_seq[2] == 0); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(cur_seq[2], 0); } TEST_P(TDMVblank, VblankWaitIgnoreGlobalFps) @@ -1231,38 +1231,38 @@ TEST_P(TDMVblank, VblankWaitIgnoreGlobalFps) unsigned int global_fps = 5; double start, end, interval; - ASSERT_TRUE(TestPrepareOutput() == true); - ASSERT_TRUE(TestCreateVblanks3() == true); - ASSERT_TRUE(vblank_count == 3); + ASSERT_EQ(TestPrepareOutput(), true); + ASSERT_EQ(TestCreateVblanks3(), true); + ASSERT_EQ(vblank_count, 3); - ASSERT_TRUE(tdm_vblank_get_fps(vblanks[0], &fps) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE); ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE); interval = 1.0 / (double)fps; /* 2nd vblank will ignore the global fps. */ - ASSERT_TRUE(tdm_vblank_ignore_global_fps(vblanks[1], 1) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[1], 1), TDM_ERROR_NONE); tdm_vblank_enable_global_fps(1, global_fps); for (int v = 0; v < 3; v++) { cur_seq[v] = 0; - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); } start = tdm_helper_get_time(); while (cur_seq[1] == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); - ASSERT_TRUE(cur_seq[0] == 0); - ASSERT_TRUE(cur_seq[2] == 0); + ASSERT_EQ(cur_seq[0], 0); + ASSERT_EQ(cur_seq[2], 0); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) < (interval + interval)); + ASSERT_LT((end - start), (interval + interval)); while (cur_seq[0] == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); - ASSERT_TRUE(cur_seq[2] != 0); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_NE(cur_seq[2], 0); } #endif diff --git a/utests/src/ut_tdm_display.cpp b/utests/src/ut_tdm_display.cpp index c1d5043..f6aaf2d 100644 --- a/utests/src/ut_tdm_display.cpp +++ b/utests/src/ut_tdm_display.cpp @@ -47,16 +47,16 @@ void TDMDisplay::SetUp(void) TDMEnv::SetUp(); dpy = tdm_display_init(&ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(dpy != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(dpy, NULL); bufmgr = tbm_bufmgr_init(-1); - ASSERT_TRUE(bufmgr != NULL); + ASSERT_NE(bufmgr, NULL); - ASSERT_TRUE(tdm_display_get_output_count(dpy, &count) == TDM_ERROR_NONE); - ASSERT_TRUE(count > 0); + ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); + ASSERT_GT(count, 0); - ASSERT_TRUE(tdm_display_get_capabilities(dpy, &capabilities) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_display_get_capabilities(dpy, &capabilities), TDM_ERROR_NONE); has_pp_cap = capabilities & TDM_DISPLAY_CAPABILITY_PP; has_capture_cap = capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE; } @@ -66,7 +66,7 @@ void TDMDisplay::TearDown(void) tbm_bufmgr_deinit(bufmgr); tdm_display_deinit(dpy); - ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0); + ASSERT_EQ(tbm_bufmgr_debug_get_ref_count(), 0); TDMEnv::TearDown(); } @@ -116,7 +116,7 @@ ut_tdm_display_has_capture_capability(tdm_display *dpy) TEST_P(TDMDisplay, DisplayUpdate) { - ASSERT_TRUE(tdm_display_update(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_display_update(dpy), TDM_ERROR_NONE); } TEST_P(TDMDisplay, DisplayUpdateWrongDpy) @@ -130,26 +130,26 @@ TEST_P(TDMDisplay, DisplayUpdateWrongDpy) TEST_P(TDMDisplay, DisplayUpdateNullObject) { - ASSERT_TRUE(tdm_display_update(NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_display_update(NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMDisplay, DisplayGetFDSuccesful) { int fd = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_fd(dpy, &fd) == TDM_ERROR_NONE); - ASSERT_TRUE(fd != TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_fd(dpy, &fd), TDM_ERROR_NONE); + ASSERT_NE(fd, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetFDNullObject) { int fd = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_fd(NULL, &fd) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(fd == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_fd(NULL, &fd), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(fd, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetFDNullFD) { - ASSERT_TRUE(tdm_display_get_fd(dpy, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_display_get_fd(dpy, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMDisplay, DisplayGetFDWrongDpy) @@ -157,15 +157,15 @@ TEST_P(TDMDisplay, DisplayGetFDWrongDpy) tdm_display *wrong_dpy = (tdm_display *)TDM_UT_INVALID_VALUE; int fd = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_fd(wrong_dpy, &fd) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(fd == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_fd(wrong_dpy, &fd), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(fd, TDM_UT_INVALID_VALUE); } /* DISABLED */ TEST_P(TDMDisplay, DISABLED_DisplayHandleEvents) { /* TODO Generate events*/ - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } TEST_P(TDMDisplay, DisplayFlush) @@ -184,11 +184,11 @@ TEST_P(TDMDisplay, DisplayGetBackendInfo) const char *vendor = (const char*)TDM_UT_INVALID_VALUE; int major = TDM_UT_INVALID_VALUE, minor = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_backend_info(dpy, &name, &vendor, &major, &minor) == TDM_ERROR_NONE); - ASSERT_TRUE(name != (const char*)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(vendor != (const char*)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(major != TDM_UT_INVALID_VALUE); - ASSERT_TRUE(minor != TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_backend_info(dpy, &name, &vendor, &major, &minor), TDM_ERROR_NONE); + ASSERT_NE(name, (const char*)TDM_UT_INVALID_VALUE); + ASSERT_NE(vendor, (const char*)TDM_UT_INVALID_VALUE); + ASSERT_NE(major, TDM_UT_INVALID_VALUE); + ASSERT_NE(minor, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetBackendInfoNullObject) @@ -197,35 +197,35 @@ TEST_P(TDMDisplay, DisplayGetBackendInfoNullObject) const char *vendor = (const char*)TDM_UT_INVALID_VALUE; int major = TDM_UT_INVALID_VALUE, minor = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_backend_info(NULL, &name, &vendor, &major, &minor) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(name == (const char*)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(vendor == (const char*)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(major == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(minor == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_backend_info(NULL, &name, &vendor, &major, &minor), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(name, (const char*)TDM_UT_INVALID_VALUE); + ASSERT_EQ(vendor, (const char*)TDM_UT_INVALID_VALUE); + ASSERT_EQ(major, TDM_UT_INVALID_VALUE); + ASSERT_EQ(minor, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetBackendInfoNullOther) { - ASSERT_TRUE(tdm_display_get_backend_info(dpy, NULL, NULL, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, NULL, NULL), TDM_ERROR_NONE); } TEST_P(TDMDisplay, DisplayGetCapabilities) { tdm_display_capability capabilities = (tdm_display_capability)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_capabilities(dpy, &capabilities) == TDM_ERROR_NONE); - ASSERT_TRUE(capabilities != TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_capabilities(dpy, &capabilities), TDM_ERROR_NONE); + ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetCapabilitiesNullObject) { tdm_display_capability capabilities = (tdm_display_capability)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_capabilities(NULL, &capabilities) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(capabilities == (tdm_display_capability)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(capabilities, (tdm_display_capability)TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetCapabilitiesNullOther) { - ASSERT_TRUE(tdm_display_get_capabilities(dpy, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_display_get_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMDisplay, DisplayGetPPCapabilities) @@ -238,19 +238,19 @@ TEST_P(TDMDisplay, DisplayGetPPCapabilities) ASSERT_TRUE(ret == TDM_ERROR_NONE || ret == TDM_ERROR_NO_CAPABILITY); if (ret == TDM_ERROR_NONE) - ASSERT_TRUE(capabilities != TDM_UT_INVALID_VALUE); + ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetPPCapabilitiesNullObject) { tdm_pp_capability capabilities = (tdm_pp_capability)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_pp_capabilities(NULL, &capabilities) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(capabilities == (tdm_pp_capability)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_pp_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(capabilities, (tdm_pp_capability)TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetPPCapabilitiesNullOther) { - ASSERT_TRUE(tdm_display_get_pp_capabilities(dpy, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_display_get_pp_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMDisplay, DisplayGetCaptureCapabilities) @@ -265,57 +265,57 @@ TEST_P(TDMDisplay, DisplayGetCaptureCapabilities) ASSERT_TRUE(ret == TDM_ERROR_NONE || ret == TDM_ERROR_NO_CAPABILITY); if (ret == TDM_ERROR_NONE) - ASSERT_TRUE(capabilities != (tdm_capture_capability)TDM_UT_INVALID_VALUE); + ASSERT_NE(capabilities, (tdm_capture_capability)TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetCaptureCapabilitiesNullObject) { tdm_capture_capability capabilities = (tdm_capture_capability)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_capture_capabilities(NULL, &capabilities) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(capabilities == (tdm_capture_capability)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_capture_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(capabilities, (tdm_capture_capability)TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetCaptureCapabilitiesNullOther) { - ASSERT_TRUE(tdm_display_get_capture_capabilities(dpy, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_display_get_capture_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMDisplay, DisplayGetMaxLayerCount) { int max_count = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_max_layer_count(dpy, &max_count) == TDM_ERROR_NONE); - ASSERT_TRUE(max_count != TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_max_layer_count(dpy, &max_count), TDM_ERROR_NONE); + ASSERT_NE(max_count, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetMaxLayerCountNullObject) { int max_count = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_max_layer_count(NULL, &max_count) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(max_count == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_max_layer_count(NULL, &max_count), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(max_count, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetMaxLayerCountNullOther) { - ASSERT_TRUE(tdm_display_get_max_layer_count(dpy, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_display_get_max_layer_count(dpy, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMDisplay, DisplayGetOutputCount) { int count = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_output_count(dpy, &count) == TDM_ERROR_NONE); - ASSERT_TRUE(count != TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); + ASSERT_NE(count, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetOutputCountNullObject) { int count = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_output_count(NULL, &count) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(count == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_display_get_output_count(NULL, &count), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(count, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetOutputCountNullOther) { - ASSERT_TRUE(tdm_display_get_output_count(dpy, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_display_get_output_count(dpy, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMDisplay, DisplayGetOutput) @@ -324,13 +324,13 @@ TEST_P(TDMDisplay, DisplayGetOutput) int o, count = TDM_UT_INVALID_VALUE; tdm_error ret; - ASSERT_TRUE(tdm_display_get_output_count(dpy, &count) == TDM_ERROR_NONE); - ASSERT_TRUE(count > 0); + ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); + ASSERT_GT(count, 0); for (o = 0; o < count; o++) { output = tdm_display_get_output(dpy, o, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(output, NULL); } } @@ -339,12 +339,12 @@ TEST_P(TDMDisplay, DisplayGetOutputNullAll) tdm_output *output; int o, count = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_output_count(dpy, &count) == TDM_ERROR_NONE); - ASSERT_TRUE(count > 0); + ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); + ASSERT_GT(count, 0); for (o = 0; o < count; o++) { output = tdm_display_get_output(NULL, o, NULL); - ASSERT_TRUE(output == NULL); + ASSERT_EQ(output, NULL); } } @@ -354,8 +354,8 @@ TEST_P(TDMDisplay, DisplayGetOutputNullObject) tdm_error ret; output = tdm_display_get_output(NULL, 0, &ret); - ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(output == NULL); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(output, NULL); } TEST_P(TDMDisplay, DisplayGetOutputNullOther) @@ -363,12 +363,12 @@ TEST_P(TDMDisplay, DisplayGetOutputNullOther) tdm_output *output; int o, count = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_output_count(dpy, &count) == TDM_ERROR_NONE); - ASSERT_TRUE(count > 0); + ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); + ASSERT_GT(count, 0); for (o = 0; o < count; o++) { output = tdm_display_get_output(dpy, o, NULL); - ASSERT_TRUE(output != NULL); + ASSERT_NE(output, NULL); } } @@ -378,12 +378,12 @@ TEST_P(TDMDisplay, DisplayGetOutputWrongIndex) tdm_error ret; output = tdm_display_get_output(dpy, -1, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output == NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_EQ(output, NULL); output = tdm_display_get_output(dpy, INT_MAX, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output == NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_EQ(output, NULL); } TEST_P(TDMDisplay, DisplayCreatePp) @@ -395,8 +395,8 @@ TEST_P(TDMDisplay, DisplayCreatePp) return; pp = tdm_display_create_pp(dpy, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(pp != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(pp, NULL); tdm_pp_destroy(pp); } @@ -410,8 +410,8 @@ TEST_P(TDMDisplay, DisplayCreatePpNullObject) return; pp = tdm_display_create_pp(NULL, &ret); - ASSERT_TRUE(ret != TDM_ERROR_NONE); - ASSERT_TRUE(pp == NULL); + ASSERT_NE(ret, TDM_ERROR_NONE); + ASSERT_EQ(pp, NULL); } TEST_P(TDMDisplay, ModuleGetInfo) @@ -420,8 +420,8 @@ TEST_P(TDMDisplay, ModuleGetInfo) int o, count = TDM_UT_INVALID_VALUE; tdm_error ret; - ASSERT_TRUE(tdm_display_get_output_count(dpy, &count) == TDM_ERROR_NONE); - ASSERT_TRUE(count > 0); + ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); + ASSERT_GT(count, 0); for (o = 0; o < count; o++) { tdm_module *module; @@ -431,18 +431,18 @@ TEST_P(TDMDisplay, ModuleGetInfo) int minor = TDM_UT_INVALID_VALUE; output = tdm_display_get_output(dpy, o, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(output, NULL); module = tdm_output_get_backend_module(output, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(module != NULL); - - ASSERT_TRUE(tdm_module_get_info(module, &name, &vendor, &major, &minor) == TDM_ERROR_NONE); - ASSERT_TRUE(name != (const char *)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(vendor != (const char *)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(major != TDM_UT_INVALID_VALUE); - ASSERT_TRUE(minor != TDM_UT_INVALID_VALUE); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(module, NULL); + + ASSERT_EQ(tdm_module_get_info(module, &name, &vendor, &major, &minor), TDM_ERROR_NONE); + ASSERT_NE(name, (const char *)TDM_UT_INVALID_VALUE); + ASSERT_NE(vendor, (const char *)TDM_UT_INVALID_VALUE); + ASSERT_NE(major, TDM_UT_INVALID_VALUE); + ASSERT_NE(minor, TDM_UT_INVALID_VALUE); } } @@ -453,11 +453,11 @@ TEST_P(TDMDisplay, ModuleGetInfoNullObject) int major = TDM_UT_INVALID_VALUE; int minor = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_module_get_info(NULL, &name, &vendor, &major, &minor) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(name == (const char *)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(vendor == (const char *)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(major == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(minor == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_module_get_info(NULL, &name, &vendor, &major, &minor), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(name, (const char *)TDM_UT_INVALID_VALUE); + ASSERT_EQ(vendor, (const char *)TDM_UT_INVALID_VALUE); + ASSERT_EQ(major, TDM_UT_INVALID_VALUE); + ASSERT_EQ(minor, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, ModuleGetInfoNullOther) @@ -466,21 +466,21 @@ TEST_P(TDMDisplay, ModuleGetInfoNullOther) int o, count = TDM_UT_INVALID_VALUE; tdm_error ret; - ASSERT_TRUE(tdm_display_get_output_count(dpy, &count) == TDM_ERROR_NONE); - ASSERT_TRUE(count > 0); + ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); + ASSERT_GT(count, 0); for (o = 0; o < count; o++) { tdm_module *module; output = tdm_display_get_output(dpy, o, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(output, NULL); module = tdm_output_get_backend_module(output, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(module != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(module, NULL); - ASSERT_TRUE(tdm_module_get_info(module, NULL, NULL, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_module_get_info(module, NULL, NULL, NULL, NULL), TDM_ERROR_NONE); } } diff --git a/utests/src/ut_tdm_env.cpp b/utests/src/ut_tdm_env.cpp index d717423..217c0bf 100644 --- a/utests/src/ut_tdm_env.cpp +++ b/utests/src/ut_tdm_env.cpp @@ -76,8 +76,8 @@ TEST_P(TDMEnv, DisplayInitDeinit) tdm_error ret; dpy = tdm_display_init(&ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(dpy != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(dpy, NULL); tdm_display_deinit(dpy); } @@ -90,8 +90,8 @@ TEST_P(TDMEnv, DisplayInitDeinitWithoutEnv) TDMEnv::TearDown(); dpy = tdm_display_init(&ret); - ASSERT_TRUE(ret == TDM_ERROR_OPERATION_FAILED); - ASSERT_TRUE(dpy == NULL); + ASSERT_EQ(ret, TDM_ERROR_OPERATION_FAILED); + ASSERT_EQ(dpy, NULL); } TEST_P(TDMEnv, DisplayInitFewTimes) @@ -102,12 +102,12 @@ TEST_P(TDMEnv, DisplayInitFewTimes) for (d = 0; d < 10; d++) { dpy[d] = tdm_display_init(&ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(dpy[d] != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(dpy[d], NULL); } for (d = 0; d < 9; d++) - ASSERT_TRUE(dpy[d] == dpy[d + 1]); + ASSERT_EQ(dpy[d], dpy[d + 1]); for (d = 0; d < 10; d++) tdm_display_deinit(dpy[d]); @@ -120,11 +120,11 @@ TEST_P(TDMEnv, DisplayInitDeinitWithTBM) tdm_error ret; bufmgr = tbm_bufmgr_init(-1); - ASSERT_TRUE(bufmgr != NULL); + ASSERT_NE(bufmgr, NULL); dpy = tdm_display_init(&ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(dpy != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(dpy, NULL); tdm_display_deinit(dpy); tbm_bufmgr_deinit(bufmgr); @@ -132,7 +132,6 @@ TEST_P(TDMEnv, DisplayInitDeinitWithTBM) TEST_P(TDMEnv, DisplayInitDeinitWithoutBackends) { - ASSERT_TRUE(1); } TEST_P(TDMEnv, DisplayInitDeinitWrongDpyBadAddress) @@ -141,8 +140,8 @@ TEST_P(TDMEnv, DisplayInitDeinitWrongDpyBadAddress) tdm_error ret; dpy = tdm_display_init(&ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(dpy != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(dpy, NULL); EXPECT_EXIT({ tdm_display *wrong_dpy = (tdm_display *)TDM_UT_INVALID_VALUE; @@ -164,8 +163,8 @@ TEST_P(TDMEnv, DisplayDeinitRepeatWithSameDpy) tdm_error ret; dpy = tdm_display_init(&ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(dpy != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(dpy, NULL); EXPECT_EXIT({ tdm_display_deinit(dpy); diff --git a/utests/src/ut_tdm_event_loop.cpp b/utests/src/ut_tdm_event_loop.cpp index 0b5f930..ddc3380 100644 --- a/utests/src/ut_tdm_event_loop.cpp +++ b/utests/src/ut_tdm_event_loop.cpp @@ -70,20 +70,20 @@ TEST_P(TDMEventLoop, EventLoopAddFdHandler) bool done; int len; - ASSERT_TRUE(pipe(pipes) == 0); + ASSERT_EQ(pipe(pipes), 0); done = false; source = tdm_event_loop_add_fd_handler(dpy, pipes[0], TDM_EVENT_LOOP_READABLE, _ut_tdm_event_loop_fd_cb, &done, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(source != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(source, NULL); len = write(pipes[1], "hello", 5); - ASSERT_TRUE(len == 5); + ASSERT_EQ(len, 5); //TODO // while (!done) -// ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); +// ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); tdm_event_loop_source_remove(source); @@ -97,8 +97,8 @@ TEST_P(TDMEventLoop, EventLoopAddFdHandlerNullObject) tdm_event_loop_source *source; source = tdm_event_loop_add_fd_handler(NULL, 0, TDM_EVENT_LOOP_READABLE, _ut_tdm_event_loop_fd_cb, NULL, &ret); - ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(source == NULL); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(source, NULL); } TEST_P(TDMEventLoop, EventLoopAddFdHandlerNullOther) @@ -106,8 +106,8 @@ TEST_P(TDMEventLoop, EventLoopAddFdHandlerNullOther) tdm_error ret; tdm_event_loop_source *source; source = tdm_event_loop_add_fd_handler(NULL, -1, TDM_EVENT_LOOP_READABLE, NULL, NULL, &ret); - ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(source == NULL); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(source, NULL); } TEST_P(TDMEventLoop, EventLoopSourceFdUpdate) @@ -118,22 +118,22 @@ TEST_P(TDMEventLoop, EventLoopSourceFdUpdate) bool done; int len; - ASSERT_TRUE(pipe(pipes) == 0); + ASSERT_EQ(pipe(pipes), 0); done = false; source = tdm_event_loop_add_fd_handler(dpy, pipes[0], TDM_EVENT_LOOP_WRITABLE, _ut_tdm_event_loop_fd_cb, &done, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(source != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(source, NULL); - ASSERT_TRUE(tdm_event_loop_source_fd_update(source, TDM_EVENT_LOOP_READABLE) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_event_loop_source_fd_update(source, TDM_EVENT_LOOP_READABLE), TDM_ERROR_NONE); len = write(pipes[1], "hello", 5); - ASSERT_TRUE(len == 5); + ASSERT_EQ(len, 5); //TODO // while (!done) -// ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); +// ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); tdm_event_loop_source_remove(source); @@ -143,7 +143,7 @@ TEST_P(TDMEventLoop, EventLoopSourceFdUpdate) TEST_P(TDMEventLoop, EventLoopSourceFdUpdateNullObject) { - ASSERT_TRUE(tdm_event_loop_source_fd_update(NULL, TDM_EVENT_LOOP_READABLE) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_event_loop_source_fd_update(NULL, TDM_EVENT_LOOP_READABLE), TDM_ERROR_INVALID_PARAMETER); } static tdm_error @@ -160,8 +160,8 @@ TEST_P(TDMEventLoop, EventLoopAddTimerHandler) tdm_error ret; tdm_event_loop_source *source; source = tdm_event_loop_add_timer_handler(dpy, _ut_tdm_event_loop_timer_cb, NULL, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(source != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(source, NULL); tdm_event_loop_source_remove(source); } @@ -170,8 +170,8 @@ TEST_P(TDMEventLoop, EventLoopAddTimerHandlerNullObject) tdm_error ret; tdm_event_loop_source *source; source = tdm_event_loop_add_timer_handler(NULL, _ut_tdm_event_loop_timer_cb, NULL, &ret); - ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(source == NULL); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(source, NULL); } @@ -180,8 +180,8 @@ TEST_P(TDMEventLoop, EventLoopAddTimerHandlerNullOther) tdm_error ret; tdm_event_loop_source *source; source = tdm_event_loop_add_timer_handler(dpy, NULL, NULL, &ret); - ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(source == NULL); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(source, NULL); } TEST_P(TDMEventLoop, EventLoopSourceTimerUpdate) @@ -189,18 +189,18 @@ TEST_P(TDMEventLoop, EventLoopSourceTimerUpdate) tdm_error ret; tdm_event_loop_source *source; source = tdm_event_loop_add_timer_handler(dpy, _ut_tdm_event_loop_timer_cb, NULL, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(source != NULL); - ASSERT_TRUE(tdm_event_loop_source_timer_update(source, 100) == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(source, NULL); + ASSERT_EQ(tdm_event_loop_source_timer_update(source, 100), TDM_ERROR_NONE); //TODO // while (!done) -// ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); +// ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); tdm_event_loop_source_remove(source); } TEST_P(TDMEventLoop, EventLoopSourceTimerUpdateNullObject) { - ASSERT_TRUE(tdm_event_loop_source_timer_update(NULL, 100) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_event_loop_source_timer_update(NULL, 100), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMEventLoop, EventLoopSourceRemoveNullObject) diff --git a/utests/src/ut_tdm_helper.cpp b/utests/src/ut_tdm_helper.cpp index ddb4e44..e0fb1ba 100644 --- a/utests/src/ut_tdm_helper.cpp +++ b/utests/src/ut_tdm_helper.cpp @@ -53,7 +53,7 @@ void TDMHelper::TearDown(void) TEST_P(TDMHelper, HelperGetTime) { - ASSERT_TRUE(tdm_helper_get_time() > 0.0); + ASSERT_GT(tdm_helper_get_time(), 0.0); } TEST_P(TDMHelper, HelperDumpBuffer) @@ -61,7 +61,7 @@ TEST_P(TDMHelper, HelperDumpBuffer) tbm_surface_h buffer; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888); - ASSERT_TRUE(buffer != NULL); + ASSERT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -90,7 +90,7 @@ TEST_P(TDMHelper, HelperClearBufferPos) tdm_pos pos = {.x = 40, .y = 40, .w = TDM_UT_BUFFER_SIZE - 80, .h = TDM_UT_BUFFER_SIZE - 80}; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888); - ASSERT_TRUE(buffer != NULL); + ASSERT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -110,7 +110,7 @@ TEST_P(TDMHelper, HelperClearBufferColor) unsigned int color = 0xffffff00; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888); - ASSERT_TRUE(buffer != NULL); + ASSERT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -128,7 +128,7 @@ TEST_P(TDMHelper, HelperClearBufferARGB) tbm_surface_h buffer; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888); - ASSERT_TRUE(buffer != NULL); + ASSERT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -146,7 +146,7 @@ TEST_P(TDMHelper, HelperClearBufferXRGB) tbm_surface_h buffer; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_XRGB8888); - ASSERT_TRUE(buffer != NULL); + ASSERT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -164,7 +164,7 @@ TEST_P(TDMHelper, HelperClearBufferYUV420) tbm_surface_h buffer; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_YUV420); - ASSERT_TRUE(buffer != NULL); + ASSERT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -182,7 +182,7 @@ TEST_P(TDMHelper, HelperClearBufferNV12) tbm_surface_h buffer; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_NV12); - ASSERT_TRUE(buffer != NULL); + ASSERT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -200,7 +200,7 @@ TEST_P(TDMHelper, HelperClearBufferNV21) tbm_surface_h buffer; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_NV21); - ASSERT_TRUE(buffer != NULL); + ASSERT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -218,7 +218,7 @@ TEST_P(TDMHelper, HelperClearBufferYUYV) tbm_surface_h buffer; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_YUYV); - ASSERT_TRUE(buffer != NULL); + ASSERT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -236,7 +236,7 @@ TEST_P(TDMHelper, HelperClearBufferUYVY) tbm_surface_h buffer; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_UYVY); - ASSERT_TRUE(buffer != NULL); + ASSERT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -255,13 +255,13 @@ TEST_P(TDMHelper, HelperGetBufferFullSize) int w = TDM_UT_INVALID_VALUE, h = TDM_UT_INVALID_VALUE; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888); - ASSERT_TRUE(buffer != NULL); + ASSERT_NE(buffer, NULL); tdm_helper_get_buffer_full_size(buffer, &w, &h); - ASSERT_TRUE(w != TDM_UT_INVALID_VALUE); - ASSERT_TRUE(w >= tbm_surface_get_width(buffer)); - ASSERT_TRUE(h != TDM_UT_INVALID_VALUE); - ASSERT_TRUE(h >= tbm_surface_get_height(buffer)); + ASSERT_NE(w, TDM_UT_INVALID_VALUE); + ASSERT_GE(w, tbm_surface_get_width(buffer)); + ASSERT_NE(h, TDM_UT_INVALID_VALUE); + ASSERT_GE(h, tbm_surface_get_height(buffer)); tbm_surface_destroy(buffer); } @@ -272,16 +272,16 @@ TEST_P(TDMHelper, HelperConvertBufferRotate0) tdm_pos sp, dp; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888); - ASSERT_TRUE(buffer != NULL); + ASSERT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888); - ASSERT_TRUE(temp != NULL); + ASSERT_NE(temp, NULL); sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE; dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2; - ASSERT_TRUE(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_NORMAL, 0) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_NORMAL, 0), TDM_ERROR_NONE); char filename[256]; snprintf(filename, sizeof filename, "%s.png", typeid(*this).name()); @@ -297,16 +297,16 @@ TEST_P(TDMHelper, HelperConvertBufferRotate0Flip) tdm_pos sp, dp; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888); - ASSERT_TRUE(buffer != NULL); + ASSERT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888); - ASSERT_TRUE(temp != NULL); + ASSERT_NE(temp, NULL); sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE; dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2; - ASSERT_TRUE(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_FLIPPED, 0) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_FLIPPED, 0), TDM_ERROR_NONE); char filename[256]; snprintf(filename, sizeof filename, "%s.png", typeid(*this).name()); @@ -322,16 +322,16 @@ TEST_P(TDMHelper, HelperConvertBufferRotate90) tdm_pos sp, dp; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888); - ASSERT_TRUE(buffer != NULL); + ASSERT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888); - ASSERT_TRUE(temp != NULL); + ASSERT_NE(temp, NULL); sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE; dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2; - ASSERT_TRUE(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_90, 0) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_90, 0), TDM_ERROR_NONE); char filename[256]; snprintf(filename, sizeof filename, "%s.png", typeid(*this).name()); @@ -347,16 +347,16 @@ TEST_P(TDMHelper, HelperConvertBufferRotate180) tdm_pos sp, dp; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888); - ASSERT_TRUE(buffer != NULL); + ASSERT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888); - ASSERT_TRUE(temp != NULL); + ASSERT_NE(temp, NULL); sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE; dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2; - ASSERT_TRUE(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_180, 0) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_180, 0), TDM_ERROR_NONE); char filename[256]; snprintf(filename, sizeof filename, "%s.png", typeid(*this).name()); @@ -372,16 +372,16 @@ TEST_P(TDMHelper, HelperConvertBufferRotate270) tdm_pos sp, dp; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888); - ASSERT_TRUE(buffer != NULL); + ASSERT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888); - ASSERT_TRUE(temp != NULL); + ASSERT_NE(temp, NULL); sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE; dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2; - ASSERT_TRUE(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_270, 0) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_270, 0), TDM_ERROR_NONE); char filename[256]; snprintf(filename, sizeof filename, "%s.png", typeid(*this).name()); @@ -397,16 +397,16 @@ TEST_P(TDMHelper, HelperConvertBufferYUV420) tdm_pos sp, dp; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_YUV420); - ASSERT_TRUE(buffer != NULL); + ASSERT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_YUV420); - ASSERT_TRUE(temp != NULL); + ASSERT_NE(temp, NULL); sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE; dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2; - ASSERT_TRUE(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_NORMAL, 0) == TDM_ERROR_OPERATION_FAILED); + ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_NORMAL, 0), TDM_ERROR_OPERATION_FAILED); tbm_surface_destroy(buffer); tbm_surface_destroy(temp); @@ -415,10 +415,10 @@ TEST_P(TDMHelper, HelperConvertBufferYUV420) TEST_P(TDMHelper, HelperGetFD) { int fd = tdm_helper_get_fd("TDM_DRM_MASTER_FD"); - ASSERT_TRUE(fd >= 0); + ASSERT_GE(fd, 0); close(fd); fd = tdm_helper_get_fd("BLURBLUR"); - ASSERT_TRUE(fd == -1); + ASSERT_EQ(fd, -1); } TEST_P(TDMHelper, HelperSetFD) @@ -450,19 +450,19 @@ TEST_P(TDMHelper, HelperCaptureOutput) tbm_surface_h dump; output = tdm_display_get_output(dpy, o, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(output, NULL); if (!ut_tdm_output_is_connected(output)) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, output, true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, output, true), true); dump = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888); - ASSERT_TRUE(dump != NULL); + ASSERT_NE(dump, NULL); - ASSERT_TRUE(tdm_helper_capture_output(output, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, - _ut_tdm_helper_capture_cb, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_helper_capture_output(output, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, + _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_NONE); char filename[256]; snprintf(filename, sizeof filename, "%s.png", typeid(*this).name()); @@ -477,8 +477,8 @@ TEST_P(TDMHelper, HelperCaptureOutputNullObject) { tbm_surface_h dump = (tbm_surface_h)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, - _ut_tdm_helper_capture_cb, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, + _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMHelper, HelperCaptureOutputNullOther) @@ -486,15 +486,15 @@ TEST_P(TDMHelper, HelperCaptureOutputNullOther) for (int o = 0; o < output_count; o++) { tdm_error ret; tdm_output *output = tdm_display_get_output(dpy, o, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(output, NULL); tdm_helper_output_commit_per_vblank_enabled(output); } tbm_surface_h dump = (tbm_surface_h)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, - _ut_tdm_helper_capture_cb, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, + _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMHelper, HelperGetDisplayInformation) @@ -505,11 +505,11 @@ TEST_P(TDMHelper, HelperGetDisplayInformation) for (int o = 0; o < output_count; o++) { tdm_error ret; tdm_output *output = tdm_display_get_output(dpy, o, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(output, NULL); if (!ut_tdm_output_is_connected(output)) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, output, true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, output, true), true); } tdm_helper_get_display_information(dpy, reply, &len); @@ -544,8 +544,8 @@ TEST_P(TDMHelper, HelperOutputCommitPerVblankEnabled) for (int o = 0; o < output_count; o++) { tdm_error ret; tdm_output *output = tdm_display_get_output(dpy, o, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(output, NULL); tdm_helper_output_commit_per_vblank_enabled(output); } } diff --git a/utests/src/ut_tdm_layer.cpp b/utests/src/ut_tdm_layer.cpp index 2a37e0e..3b830a0 100644 --- a/utests/src/ut_tdm_layer.cpp +++ b/utests/src/ut_tdm_layer.cpp @@ -71,17 +71,17 @@ void TDMLayer::SetUp(void) if (ut_tdm_output_is_hwc_enable(outputs[o])) continue; - ASSERT_TRUE(tdm_output_get_layer_count(outputs[o], &count) == TDM_ERROR_NONE); - ASSERT_TRUE(count > 0); + ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE); + ASSERT_GT(count, 0); layer_count += count; layers = (tdm_layer**)realloc(layers, sizeof(tdm_layer*) * layer_count); - ASSERT_TRUE(layers != NULL); + ASSERT_NE(layers, NULL); for (int l = 0; l < count; l++) { tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret); - ASSERT_TRUE(layer != NULL); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_NE(layer, NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); layers[old_layer_count + l] = layer; } } @@ -93,7 +93,7 @@ void TDMLayer::SetUp(void) void TDMLayer::TearDown(void) { for (int l = 0; l < layer_count; l++) { - ASSERT_TRUE(tdm_layer_unset_buffer(layers[l]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); } free(layers); @@ -381,8 +381,8 @@ TEST_P(TDMLayer, LayerGetOutput) for (int l = 0; l < layer_count; l++) { tdm_error ret; tdm_output *output = tdm_layer_get_output(layers[l], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(output, NULL); } } @@ -392,8 +392,8 @@ TEST_P(TDMLayer, LayerGetOutputNullObject) tdm_error ret; tdm_output *output = tdm_layer_get_output(NULL, &ret); - ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(output == NULL); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(output, NULL); } TEST_P(TDMLayer, LayerGetOutputNullParam) @@ -402,7 +402,7 @@ TEST_P(TDMLayer, LayerGetOutputNullParam) for (int l = 0; l < layer_count; l++) { tdm_output *output = tdm_layer_get_output(layers[l], NULL); - ASSERT_TRUE(output != NULL); + ASSERT_NE(output, NULL); } } @@ -412,8 +412,8 @@ TEST_P(TDMLayer, LayerGetCapabilities) for (int l = 0; l < layer_count; l++) { tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_layer_get_capabilities(layers[l], &capabilities) == TDM_ERROR_NONE); - ASSERT_TRUE(capabilities != TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_layer_get_capabilities(layers[l], &capabilities), TDM_ERROR_NONE); + ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE); } } @@ -422,14 +422,14 @@ TEST_P(TDMLayer, LayerGetCapabilitiesNullObject) TDM_UT_SKIP_FLAG(has_layers); tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_layer_get_capabilities(NULL, &capabilities) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(capabilities == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_layer_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(capabilities, TDM_UT_INVALID_VALUE); } TEST_P(TDMLayer, LayerGetCapabilitiesNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_TRUE(tdm_layer_get_capabilities(layers[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_get_capabilities(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerGetAvailableFormats) @@ -441,9 +441,9 @@ TEST_P(TDMLayer, LayerGetAvailableFormats) continue; const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_layer_get_available_formats(layers[l], &formats, &count) == TDM_ERROR_NONE); - ASSERT_TRUE(formats != NULL); - ASSERT_TRUE(count > 0); + ASSERT_EQ(tdm_layer_get_available_formats(layers[l], &formats, &count), TDM_ERROR_NONE); + ASSERT_NE(formats, NULL); + ASSERT_GT(count, 0); } } @@ -453,9 +453,9 @@ TEST_P(TDMLayer, LayerGetAvailableFormatsNullObject) const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_layer_get_available_formats(NULL, &formats, &count) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(formats == (const tbm_format *)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(count == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_layer_get_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE); + ASSERT_EQ(count, TDM_UT_INVALID_VALUE); } TEST_P(TDMLayer, LayerGetAvailableFormatsNullOther) @@ -463,7 +463,7 @@ TEST_P(TDMLayer, LayerGetAvailableFormatsNullOther) TDM_UT_SKIP_FLAG(has_layers); if (!ut_tdm_layer_is_avaiable(layers[0])) return; - ASSERT_TRUE(tdm_layer_get_available_formats(layers[0], NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_get_available_formats(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerGetAvailableProperties) @@ -475,8 +475,8 @@ TEST_P(TDMLayer, LayerGetAvailableProperties) continue; const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_layer_get_available_properties(layers[l], &props, &count) == TDM_ERROR_NONE); - ASSERT_TRUE(count >= 0); + ASSERT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE); + ASSERT_GE(count, 0); if (count > 0) ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE); } @@ -488,16 +488,16 @@ TEST_P(TDMLayer, LayerGetAvailablePropertiesNullObject) const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_layer_get_available_properties(NULL, &props, &count) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(props == (const tdm_prop *)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(count == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_layer_get_available_properties(NULL, &props, &count), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(props, (const tdm_prop *)TDM_UT_INVALID_VALUE); + ASSERT_EQ(count, TDM_UT_INVALID_VALUE); } TEST_P(TDMLayer, LayerGetAvailablePropertiesNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_TRUE(tdm_layer_get_available_properties(layers[0], NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_get_available_properties(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerGetZpos) @@ -505,7 +505,7 @@ TEST_P(TDMLayer, LayerGetZpos) TDM_UT_SKIP_FLAG(has_layers); bool *check_table = (bool*)calloc(layer_count, output_count); - ASSERT_TRUE(check_table != NULL); + ASSERT_NE(check_table, NULL); for (int l = 0; l < layer_count; l++) { if (!ut_tdm_layer_is_avaiable(layers[l])) @@ -530,15 +530,15 @@ TEST_P(TDMLayer, LayerGetZposNullObject) TDM_UT_SKIP_FLAG(has_layers); int zpos = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_layer_get_zpos(NULL, &zpos) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(zpos == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_layer_get_zpos(NULL, &zpos), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(zpos, TDM_UT_INVALID_VALUE); } TEST_P(TDMLayer, LayerGetZposNullParam) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_TRUE(tdm_layer_get_zpos(layers[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_get_zpos(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerSetProperty) @@ -553,11 +553,11 @@ TEST_P(TDMLayer, LayerSetProperty) int count = TDM_UT_INVALID_VALUE; tdm_value value = {.s32 = 0}; - ASSERT_TRUE(tdm_layer_get_available_properties(layers[l], &props, &count) == TDM_ERROR_NONE); - ASSERT_TRUE(count >= 0); + ASSERT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE); + ASSERT_GE(count, 0); if (count > 0) - ASSERT_TRUE(tdm_layer_set_property(layers[l], props[0].id, value) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_property(layers[l], props[0].id, value), TDM_ERROR_NONE); } } @@ -565,7 +565,7 @@ TEST_P(TDMLayer, LayerSetPropertyNullObject) { tdm_value value = {.s32 = 0}; - ASSERT_TRUE(tdm_layer_set_property(NULL, 0, value) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerGetProperty) @@ -578,15 +578,15 @@ TEST_P(TDMLayer, LayerGetProperty) const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_layer_get_available_properties(layers[l], &props, &count) == TDM_ERROR_NONE); - ASSERT_TRUE(count >= 0); + ASSERT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE); + ASSERT_GE(count, 0); if (count > 0) { ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE); for (int i = 0; i < count; i++) { tdm_value value = {.s32 = TDM_UT_INVALID_VALUE}; - ASSERT_TRUE(tdm_layer_get_property(layers[l], props[i].id, &value) == TDM_ERROR_NONE); - ASSERT_TRUE(value.s32 != TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_layer_get_property(layers[l], props[i].id, &value), TDM_ERROR_NONE); + ASSERT_NE(value.s32, TDM_UT_INVALID_VALUE); } } } @@ -597,15 +597,15 @@ TEST_P(TDMLayer, LayerGetPropertyNullObject) TDM_UT_SKIP_FLAG(has_layers); tdm_value value = {.s32 = TDM_UT_INVALID_VALUE}; - ASSERT_TRUE(tdm_layer_get_property(NULL, 0, &value) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(value.s32 == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_layer_get_property(NULL, 0, &value), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(value.s32, TDM_UT_INVALID_VALUE); } TEST_P(TDMLayer, LayerGetPropertyNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_TRUE(tdm_layer_get_property(layers[0], 0, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_get_property(layers[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerSetInfo) @@ -619,8 +619,8 @@ TEST_P(TDMLayer, LayerSetInfo) continue; tdm_info_layer info; - ASSERT_TRUE(ut_tdm_layer_fill_info(layers[l], -1, -1, 0, &info) == true); - ASSERT_TRUE(tdm_layer_set_info(layers[l], &info) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_layer_fill_info(layers[l], -1, -1, 0, &info), true); + ASSERT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE); } } @@ -630,14 +630,14 @@ TEST_P(TDMLayer, LayerSetInfoNullObject) tdm_info_layer info; memset(&info, 0, sizeof info); - ASSERT_TRUE(tdm_layer_set_info(NULL, &info) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerSetInfoNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_TRUE(tdm_layer_set_info(layers[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_set_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, DISABLED_LayerGetInfo) @@ -650,14 +650,14 @@ TEST_P(TDMLayer, LayerGetInfoNullObject) tdm_info_layer temp; - ASSERT_TRUE(tdm_layer_get_info(NULL, &temp) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_get_info(NULL, &temp), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerGetInfoNullParam) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_TRUE(tdm_layer_get_info(layers[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_get_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerGetBufferFlags) @@ -669,8 +669,8 @@ TEST_P(TDMLayer, LayerGetBufferFlags) continue; unsigned int flags = (unsigned int)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_layer_get_buffer_flags(layers[l], &flags) == TDM_ERROR_NONE); - ASSERT_TRUE(flags != (unsigned int)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_layer_get_buffer_flags(layers[l], &flags), TDM_ERROR_NONE); + ASSERT_NE(flags, (unsigned int)TDM_UT_INVALID_VALUE); } } @@ -679,15 +679,15 @@ TEST_P(TDMLayer, LayerGetBufferFlagsNullObject) TDM_UT_SKIP_FLAG(has_layers); unsigned int flags = (unsigned int)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_layer_get_buffer_flags(NULL, &flags) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(flags == (unsigned int)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_layer_get_buffer_flags(NULL, &flags), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(flags, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMLayer, LayerGetBufferFlagsNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_TRUE(tdm_layer_get_buffer_flags(layers[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_get_buffer_flags(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } static void @@ -720,25 +720,25 @@ TEST_P(TDMLayer, LayerSetBuffer) if (ut_tdm_layer_is_video_layer(layers[l])) continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set info */ int bw = tbm_surface_get_width(buffers[0]); int bh = tbm_surface_get_height(buffers[0]); tbm_format bf = tbm_surface_get_format(buffers[0]); - ASSERT_TRUE(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info) == true); + ASSERT_EQ(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info), true); - ASSERT_TRUE(tdm_layer_set_info(layers[l], &info) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE); /* set buffer & commit for 100 times */ for (int t = 0; t < 10; t++) { tbm_surface_h displaying_buffer = NULL; - ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer]) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layers[l], buffers[next_buffer]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); while (displaying_buffer != buffers[next_buffer]) { - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); } next_buffer++; if (next_buffer == 3) @@ -769,27 +769,27 @@ TEST_P(TDMLayer, LayerSetBufferFewTimeInOneCommit) if (ut_tdm_layer_is_video_layer(layers[l])) continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set info */ int bw = tbm_surface_get_width(buffers[0]); int bh = tbm_surface_get_height(buffers[0]); tbm_format bf = tbm_surface_get_format(buffers[0]); - ASSERT_TRUE(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info) == true); - ASSERT_TRUE(tdm_layer_set_info(layers[l], &info) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info), true); + ASSERT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE); /* set buffer & commit for 10 times */ for (int t = 0; t < 10; t++) { tbm_surface_h displaying_buffer = NULL; - ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), TDM_ERROR_NONE); if (next_buffer == 3) next_buffer = 0; - ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer]) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layers[l], buffers[next_buffer]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); while (displaying_buffer != buffers[next_buffer]) { - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); } next_buffer++; if (next_buffer == 3) @@ -805,14 +805,14 @@ TEST_P(TDMLayer, LayerSetBufferNullObject) TDM_UT_SKIP_FLAG(has_layers); tbm_surface_h buffer = (tbm_surface_h)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_layer_set_buffer(NULL, buffer) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_set_buffer(NULL, buffer), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerSetBufferNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_TRUE(tdm_layer_set_buffer(layers[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_set_buffer(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerUnsetBuffer) @@ -825,7 +825,7 @@ TEST_P(TDMLayer, LayerUnsetBuffer) if (!ut_tdm_layer_is_avaiable(layers[l])) continue; - ASSERT_TRUE(tdm_layer_unset_buffer(layers[l]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); } } @@ -833,7 +833,7 @@ TEST_P(TDMLayer, LayerUnsetBufferNullObject) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_TRUE(tdm_layer_unset_buffer(NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_unset_buffer(NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerUnsetBufferBeforeCommit) @@ -856,26 +856,26 @@ TEST_P(TDMLayer, LayerUnsetBufferBeforeCommit) if (ut_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set info */ int bw = tbm_surface_get_width(buffers[0]); int bh = tbm_surface_get_height(buffers[0]); tbm_format bf = tbm_surface_get_format(buffers[0]); - ASSERT_TRUE(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info) == true); - ASSERT_TRUE(tdm_layer_set_info(layers[l], &info) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info), true); + ASSERT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE); /* set buffer & commit for 10 times */ for (int t = 0; t < 10; t++) { - ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), TDM_ERROR_NONE); if (next_buffer == 3) next_buffer = 0; - ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), TDM_ERROR_NONE); if (next_buffer == 3) next_buffer = 0; } - ASSERT_TRUE(tdm_layer_unset_buffer(layers[l]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); DestroyBuffers(); } @@ -901,20 +901,20 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommit) if (ut_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set info */ int bw = tbm_surface_get_width(buffers[0]); int bh = tbm_surface_get_height(buffers[0]); tbm_format bf = tbm_surface_get_format(buffers[0]); - ASSERT_TRUE(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info) == true); - ASSERT_TRUE(tdm_layer_set_info(layers[l], &info) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info), true); + ASSERT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_unset_buffer(layers[l]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); DestroyBuffers(); } @@ -941,22 +941,22 @@ TEST_P(TDMLayer, DISABLED_LayerUnsetBufferAfterTwoCommit) if (ut_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set info */ int bw = tbm_surface_get_width(buffers[0]); int bh = tbm_surface_get_height(buffers[0]); tbm_format bf = tbm_surface_get_format(buffers[0]); - ASSERT_TRUE(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info) == true); - ASSERT_TRUE(tdm_layer_set_info(layers[l], &info) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info), true); + ASSERT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_unset_buffer(layers[l]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); DestroyBuffers(); } @@ -983,24 +983,24 @@ TEST_P(TDMLayer, DISABLED_LayerUnsetBufferAfterTwoCommitOneSetBuffer) if (ut_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set info */ int bw = tbm_surface_get_width(buffers[0]); int bh = tbm_surface_get_height(buffers[0]); tbm_format bf = tbm_surface_get_format(buffers[0]); - ASSERT_TRUE(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info) == true); - ASSERT_TRUE(tdm_layer_set_info(layers[l], &info) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info), true); + ASSERT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layers[l], buffers[next_buffer]), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_unset_buffer(layers[l]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); DestroyBuffers(); } @@ -1027,26 +1027,26 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDone) if (ut_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set info */ int bw = tbm_surface_get_width(buffers[0]); int bh = tbm_surface_get_height(buffers[0]); tbm_format bf = tbm_surface_get_format(buffers[0]); - ASSERT_TRUE(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info) == true); - ASSERT_TRUE(tdm_layer_set_info(layers[l], &info) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info), true); + ASSERT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE); /* set buffer & commit for 10 times */ - ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), TDM_ERROR_NONE); done = false; - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done), TDM_ERROR_NONE); while (!done) { - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } - ASSERT_TRUE(tdm_layer_unset_buffer(layers[l]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); DestroyBuffers(); } @@ -1073,30 +1073,30 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDoneOneCommit) if (ut_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set info */ int bw = tbm_surface_get_width(buffers[0]); int bh = tbm_surface_get_height(buffers[0]); tbm_format bf = tbm_surface_get_format(buffers[0]); - ASSERT_TRUE(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info) == true); - ASSERT_TRUE(tdm_layer_set_info(layers[l], &info) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info), true); + ASSERT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE); /* set buffer & commit for 10 times */ - ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), TDM_ERROR_NONE); done = false; - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done), TDM_ERROR_NONE); while (!done) { - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } - ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), TDM_ERROR_NONE); next_buffer = 0; - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_unset_buffer(layers[l]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); DestroyBuffers(); } @@ -1108,8 +1108,8 @@ TEST_P(TDMLayer, LayerCommitDPMSOff) tdm_error ret; tdm_output *output = tdm_layer_get_output(layers[0], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(output, NULL); if (!ut_tdm_output_is_connected(output)) return; @@ -1127,7 +1127,7 @@ TEST_P(TDMLayer, LayerCommitNullObject) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_TRUE(tdm_layer_commit(NULL, _ut_tdm_layer_commit_cb, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_commit(NULL, _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerCommitNullOther) @@ -1136,7 +1136,7 @@ TEST_P(TDMLayer, LayerCommitNullOther) ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); - ASSERT_TRUE(tdm_layer_commit(layers[0], NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[0], NULL, NULL), TDM_ERROR_NONE); } TEST_P(TDMLayer, LayerIsCommittingNullObject) @@ -1144,15 +1144,15 @@ TEST_P(TDMLayer, LayerIsCommittingNullObject) TDM_UT_SKIP_FLAG(has_layers); unsigned int committing = (unsigned int)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_layer_is_committing(NULL, &committing) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(committing == (unsigned int)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_layer_is_committing(NULL, &committing), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(committing, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMLayer, LayerIsCommittingNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_TRUE(tdm_layer_is_committing(layers[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_is_committing(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerRemoveCommitHandler) @@ -1167,8 +1167,8 @@ TEST_P(TDMLayer, LayerRemoveCommitHandler) tdm_error ret; tdm_output *output = tdm_layer_get_output(layers[l], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(output, NULL); if (ut_tdm_layer_is_cursor_layer(layers[l])) continue; @@ -1177,25 +1177,25 @@ TEST_P(TDMLayer, LayerRemoveCommitHandler) if (ut_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer(layers[l], buffers, 1, true) == true); + ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true); /* set info */ tdm_info_layer info; int bw = tbm_surface_get_width(buffers[0]); int bh = tbm_surface_get_height(buffers[0]); tbm_format bf = tbm_surface_get_format(buffers[0]); - ASSERT_TRUE(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info) == true); - ASSERT_TRUE(tdm_layer_set_info(layers[l], &info) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_set_buffer(layers[l], buffers[0]) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info), true); + ASSERT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer(layers[l], buffers[0]), TDM_ERROR_NONE); for (int t = 0; t < 10; t++) { bool done1 = false, done2 = false, done3 = false; - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done2) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done3) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_remove_commit_handler(layers[l], _ut_tdm_layer_commit_cb, &done2) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_remove_commit_handler(layers[l], _ut_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE); while (!done1 || done2 || !done3) { - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } @@ -1215,8 +1215,8 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerDifferentData) tdm_error ret; tdm_output *output = tdm_layer_get_output(layers[l], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(output, NULL); if (ut_tdm_layer_is_cursor_layer(layers[l])) continue; @@ -1227,12 +1227,12 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerDifferentData) for (int t = 0; t < 10; t++) { bool done1 = false, done2 = false, done3 = false; - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done2) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done3) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_remove_commit_handler(layers[l], _ut_tdm_layer_commit_cb, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_remove_commit_handler(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); while (!done1 || !done2 || !done3) { - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1245,7 +1245,7 @@ _ut_tdm_layer_commit_cb2(tdm_layer *layer, unsigned int sequence, bool *done = (bool*)user_data; if (done) *done = true; - ASSERT_TRUE(tdm_layer_remove_commit_handler(layer, _ut_tdm_layer_commit_cb2, user_data) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_remove_commit_handler(layer, _ut_tdm_layer_commit_cb2, user_data), TDM_ERROR_NONE); } TEST_P(TDMLayer, LayerRemoveCommitHandlerInHandler) @@ -1260,8 +1260,8 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerInHandler) tdm_error ret; tdm_output *output = tdm_layer_get_output(layers[l], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(output, NULL); if (ut_tdm_layer_is_cursor_layer(layers[l])) continue; @@ -1272,11 +1272,11 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerInHandler) for (int t = 0; t < 10; t++) { bool done1 = false, done2 = false, done3 = false; - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb2, &done1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb2, &done2) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb2, &done3) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb2, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb2, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb2, &done3), TDM_ERROR_NONE); while (!done1 || !done2 || !done3) { - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1286,14 +1286,14 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerNullObject) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_TRUE(tdm_layer_remove_commit_handler(NULL, _ut_tdm_layer_commit_cb, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_remove_commit_handler(NULL, _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerRemoveCommitHandlerNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_TRUE(tdm_layer_remove_commit_handler(layers[0], NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_remove_commit_handler(layers[0], NULL, NULL), TDM_ERROR_NONE); } TEST_P(TDMLayer, LayerGetDisplayingBufferNullObject) @@ -1303,8 +1303,8 @@ TEST_P(TDMLayer, LayerGetDisplayingBufferNullObject) tbm_surface_h displaying_buffer; tdm_error ret; displaying_buffer = tdm_layer_get_displaying_buffer(NULL, &ret); - ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(displaying_buffer == NULL); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(displaying_buffer, NULL); } TEST_P(TDMLayer, LayerGetDisplayingBufferNullOther) @@ -1313,7 +1313,7 @@ TEST_P(TDMLayer, LayerGetDisplayingBufferNullOther) tbm_surface_h displaying_buffer; displaying_buffer = tdm_layer_get_displaying_buffer(layers[0], NULL); - ASSERT_TRUE(displaying_buffer == NULL); + ASSERT_EQ(displaying_buffer, NULL); } TEST_P(TDMLayer, LayerIsUsableNullObject) @@ -1321,8 +1321,8 @@ TEST_P(TDMLayer, LayerIsUsableNullObject) TDM_UT_SKIP_FLAG(has_layers); unsigned int usable = (unsigned int)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_layer_is_usable(NULL, &usable) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(usable == (unsigned int)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_layer_is_usable(NULL, &usable), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(usable, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMLayer, LayerSetBufferQueue) @@ -1348,35 +1348,35 @@ TEST_P(TDMLayer, LayerSetBufferQueue) if (ut_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_TRUE(ut_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue) == true); - ASSERT_TRUE(buffer_queue != NULL); + ASSERT_EQ(ut_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue), true); + ASSERT_NE(buffer_queue, NULL); /* set info */ int bw = tbm_surface_queue_get_width(buffer_queue); int bh = tbm_surface_queue_get_height(buffer_queue); tbm_format bf = tbm_surface_queue_get_format(buffer_queue); - ASSERT_TRUE(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info) == true); + ASSERT_EQ(ut_tdm_layer_fill_info(layers[l], bw, bh, bf, &info), true); - ASSERT_TRUE(tdm_layer_set_info(layers[l], &info) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_set_buffer_queue(layers[l], buffer_queue) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_buffer_queue(layers[l], buffer_queue), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_layer_commit(layers[l], NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], NULL, NULL), TDM_ERROR_NONE); for (int t = 0; t < 10; t++) { - ASSERT_TRUE(tbm_surface_queue_dequeue(buffer_queue, &buffer) == TBM_SURFACE_QUEUE_ERROR_NONE); - ASSERT_TRUE(buffer != NULL); + ASSERT_EQ(tbm_surface_queue_dequeue(buffer_queue, &buffer), TBM_SURFACE_QUEUE_ERROR_NONE); + ASSERT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); - ASSERT_TRUE(tbm_surface_queue_enqueue(buffer_queue, buffer) == TBM_SURFACE_QUEUE_ERROR_NONE); + ASSERT_EQ(tbm_surface_queue_enqueue(buffer_queue, buffer), TBM_SURFACE_QUEUE_ERROR_NONE); displaying_buffer = NULL; while (displaying_buffer != buffer) { - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); } } - ASSERT_TRUE(tdm_layer_unset_buffer_queue(layers[l]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_unset_buffer_queue(layers[l]), TDM_ERROR_NONE); DestroyBuffers(); } @@ -1420,28 +1420,28 @@ TEST_P(TDMLayer, LayerSetBufferQueueNullObject) tbm_surface_queue_h buffer_queue = (tbm_surface_queue_h)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_layer_set_buffer_queue(NULL, buffer_queue) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_set_buffer_queue(NULL, buffer_queue), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerSetBufferQueueNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_TRUE(tdm_layer_set_buffer_queue(layers[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_set_buffer_queue(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerUnsetBufferQueueNullObject) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_TRUE(tdm_layer_unset_buffer_queue(NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_unset_buffer_queue(NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerIsUsableNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_TRUE(tdm_layer_is_usable(layers[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_is_usable(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerSetVideoPos) @@ -1454,7 +1454,7 @@ TEST_P(TDMLayer, LayerSetVideoPos) if (!ut_tdm_layer_is_video_layer(layers[l])) continue; - ASSERT_TRUE(tdm_layer_set_video_pos(layers[l], -1) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_NONE); } } @@ -1462,7 +1462,7 @@ TEST_P(TDMLayer, LayerSetVideoPosNullObject) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_TRUE(tdm_layer_set_video_pos(NULL, -1) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_set_video_pos(NULL, -1), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerSetVideoPosNoVideoLayer) @@ -1476,7 +1476,7 @@ TEST_P(TDMLayer, LayerSetVideoPosNoVideoLayer) if (ut_tdm_layer_is_video_layer(layers[l])) continue; - ASSERT_TRUE(tdm_layer_set_video_pos(layers[l], -1) == TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_BAD_REQUEST); } } @@ -1493,7 +1493,7 @@ TEST_P(TDMLayer, LayerCreateCapture) capture = tdm_layer_create_capture(layers[l], &ret); if (ret == TDM_ERROR_NONE) - ASSERT_TRUE(capture != NULL); + ASSERT_NE(capture, NULL); } } @@ -1503,8 +1503,8 @@ TEST_P(TDMLayer, LayerCreateCaptureNullObject) tdm_error ret; tdm_capture *capture = tdm_layer_create_capture(NULL, &ret); - ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(capture == NULL); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(capture, NULL); } #ifdef TDM_UT_TEST_WITH_PARAMS diff --git a/utests/src/ut_tdm_output.cpp b/utests/src/ut_tdm_output.cpp index 32aa528..ab7dfa7 100644 --- a/utests/src/ut_tdm_output.cpp +++ b/utests/src/ut_tdm_output.cpp @@ -46,18 +46,18 @@ void TDMOutput::SetUp(void) { TDMDisplay::SetUp(); - ASSERT_TRUE(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE); - ASSERT_TRUE(output_count >= 0); + ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE); + ASSERT_GE(output_count, 0); if (output_count > 0) { outputs = (tdm_output**)calloc(output_count, sizeof (tdm_output*)); - ASSERT_TRUE(outputs != NULL); + ASSERT_NE(outputs, NULL); for (int o = 0; o < output_count; o++) { tdm_error ret; tdm_output *output = tdm_display_get_output(dpy, o, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(output != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(output, NULL); outputs[o] = output; } has_outputs = true; @@ -70,7 +70,7 @@ void TDMOutput::TearDown(void) { if (outputs) { for (int o = 0; o < output_count; o++) { - ASSERT_TRUE(ut_tdm_output_unset(dpy, outputs[o]) == true); + ASSERT_EQ(ut_tdm_output_unset(dpy, outputs[o]), true); tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1); tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, &done2); tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, &done3); @@ -291,8 +291,8 @@ TEST_P(TDMOutput, OutputGetBackendModule) for (int o = 0; o < output_count; o++) { tdm_error ret = (tdm_error)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_backend_module(outputs[o], &ret) != NULL); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_NE(tdm_output_get_backend_module(outputs[o], &ret), NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); } } @@ -301,8 +301,8 @@ TEST_P(TDMOutput, OutputGetBackendModuleNullOBject) TDM_UT_SKIP_FLAG(has_outputs); tdm_error ret = (tdm_error)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_backend_module(NULL, &ret) == NULL); - ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_get_backend_module(NULL, &ret), NULL); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetBackendModuleNullOther) @@ -310,7 +310,7 @@ TEST_P(TDMOutput, OutputGetBackendModuleNullOther) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - ASSERT_TRUE(tdm_output_get_backend_module(outputs[o], NULL) != NULL); + ASSERT_NE(tdm_output_get_backend_module(outputs[o], NULL), NULL); } } @@ -320,8 +320,8 @@ TEST_P(TDMOutput, OutputGetCapabilities) for (int o = 0; o < output_count; o++) { tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_capabilities(outputs[o], &capabilities) == TDM_ERROR_NONE); - ASSERT_TRUE(capabilities != TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_capabilities(outputs[o], &capabilities), TDM_ERROR_NONE); + ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE); } } @@ -330,15 +330,15 @@ TEST_P(TDMOutput, OutputGetCapabilitiesNullObject) TDM_UT_SKIP_FLAG(has_outputs); tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_capabilities(NULL, &capabilities) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(capabilities == (tdm_output_capability)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(capabilities, (tdm_output_capability)TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetCapabilitiesNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_get_capabilities(outputs[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_get_capabilities(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetModelInfo) @@ -347,10 +347,10 @@ TEST_P(TDMOutput, OutputGetModelInfo) for (int o = 0; o < output_count; o++) { const char *maker = NULL, *model = NULL, *name = NULL; - ASSERT_TRUE(tdm_output_get_model_info(outputs[o], &maker, &model, &name) == TDM_ERROR_NONE); - ASSERT_TRUE(maker != NULL); - ASSERT_TRUE(model != NULL); - ASSERT_TRUE(name != NULL); + ASSERT_EQ(tdm_output_get_model_info(outputs[o], &maker, &model, &name), TDM_ERROR_NONE); + ASSERT_NE(maker, NULL); + ASSERT_NE(model, NULL); + ASSERT_NE(name, NULL); } } @@ -362,17 +362,17 @@ TEST_P(TDMOutput, OutputGetModelInfoNullObject) const char *model = (const char*)TDM_UT_INVALID_VALUE; const char *name = (const char*)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_model_info(NULL, &maker, &model, &name) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(maker == (const char*)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(model == (const char*)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(name == (const char*)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_model_info(NULL, &maker, &model, &name), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(maker, (const char*)TDM_UT_INVALID_VALUE); + ASSERT_EQ(model, (const char*)TDM_UT_INVALID_VALUE); + ASSERT_EQ(name, (const char*)TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetModelInfoNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_get_model_info(outputs[0], NULL, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_model_info(outputs[0], NULL, NULL, NULL), TDM_ERROR_NONE); } TEST_P(TDMOutput, OutputGetConnStatus) @@ -381,8 +381,8 @@ TEST_P(TDMOutput, OutputGetConnStatus) for (int o = 0; o < output_count; o++) { tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_conn_status(outputs[o], &status) == TDM_ERROR_NONE); - ASSERT_TRUE(status != TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_conn_status(outputs[o], &status), TDM_ERROR_NONE); + ASSERT_NE(status, TDM_UT_INVALID_VALUE); } } @@ -392,15 +392,15 @@ TEST_P(TDMOutput, OutputGetConnStatusNullObject) tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_conn_status(NULL, &status) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(status == (tdm_output_conn_status)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_conn_status(NULL, &status), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetConnStatusNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_get_conn_status(outputs[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_get_conn_status(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetOutputType) @@ -409,8 +409,8 @@ TEST_P(TDMOutput, OutputGetOutputType) for (int o = 0; o < output_count; o++) { tdm_output_type type = (tdm_output_type)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_output_type(outputs[o], &type) == TDM_ERROR_NONE); - ASSERT_TRUE(type != TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_output_type(outputs[o], &type), TDM_ERROR_NONE); + ASSERT_NE(type, TDM_UT_INVALID_VALUE); } } @@ -419,15 +419,15 @@ TEST_P(TDMOutput, OutputGetOutputTypeNullObject) TDM_UT_SKIP_FLAG(has_outputs); tdm_output_type type = (tdm_output_type)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_output_type(NULL, &type) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(type == (tdm_output_type)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_output_type(NULL, &type), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(type, (tdm_output_type)TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetOutputTypeNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_get_output_type(outputs[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_get_output_type(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetLayerCount) @@ -437,11 +437,11 @@ TEST_P(TDMOutput, OutputGetLayerCount) for (int o = 0; o < output_count; o++) { int count = TDM_UT_INVALID_VALUE; if (ut_tdm_output_is_hwc_enable(outputs[o])) { - ASSERT_TRUE(tdm_output_get_layer_count(outputs[o], &count) == TDM_ERROR_BAD_REQUEST); - ASSERT_TRUE(count == 0); + ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(count, 0); } else { - ASSERT_TRUE(tdm_output_get_layer_count(outputs[o], &count) == TDM_ERROR_NONE); - ASSERT_TRUE(count > 0); + ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE); + ASSERT_GT(count, 0); } } } @@ -451,15 +451,15 @@ TEST_P(TDMOutput, OutputGetLayerCountNullObject) TDM_UT_SKIP_FLAG(has_outputs); int count = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_layer_count(NULL, &count) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(count == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_layer_count(NULL, &count), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(count, TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetLayerCountNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_get_layer_count(outputs[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_get_layer_count(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetLayer) @@ -472,20 +472,20 @@ TEST_P(TDMOutput, OutputGetLayer) int layer_count = TDM_UT_INVALID_VALUE; if (ut_tdm_output_is_hwc_enable(outputs[o])) { - ASSERT_TRUE(tdm_output_get_layer_count(outputs[o], &layer_count) == TDM_ERROR_BAD_REQUEST); - ASSERT_TRUE(layer_count == 0); + ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(layer_count, 0); layer = tdm_output_get_layer(outputs[o], 0, &ret); - ASSERT_TRUE(ret == TDM_ERROR_BAD_REQUEST); - ASSERT_TRUE(layer == NULL); + ASSERT_EQ(ret, TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(layer, NULL); } else { - ASSERT_TRUE(tdm_output_get_layer_count(outputs[o], &layer_count) == TDM_ERROR_NONE); - ASSERT_TRUE(layer_count > 0); + ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_NONE); + ASSERT_GT(layer_count, 0); for (int l = 0; l < layer_count; l++) { tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(layer != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(layer, NULL); } } } @@ -497,8 +497,8 @@ TEST_P(TDMOutput, OutputGetLayerNullObject) tdm_error ret; tdm_layer *layer = tdm_output_get_layer(NULL, 0, &ret); - ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(layer == NULL); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(layer, NULL); } TEST_P(TDMOutput, OutputGetLayerNullOther) @@ -508,10 +508,10 @@ TEST_P(TDMOutput, OutputGetLayerNullOther) tdm_layer *layer; if (ut_tdm_output_is_hwc_enable(outputs[0])) { layer = tdm_output_get_layer(outputs[0], 0, NULL); - ASSERT_TRUE(layer == NULL); + ASSERT_EQ(layer, NULL); } else { layer = tdm_output_get_layer(outputs[0], 0, NULL); - ASSERT_TRUE(layer != NULL); + ASSERT_NE(layer, NULL); } } @@ -522,8 +522,8 @@ TEST_P(TDMOutput, OutputGetAvailableProperties) for (int o = 0; o < output_count; o++) { int count = TDM_UT_INVALID_VALUE; const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_available_properties(outputs[o], &props, &count) == TDM_ERROR_NONE); - ASSERT_TRUE(count >= 0); + ASSERT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE); + ASSERT_GE(count, 0); if (count > 0) ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE); } @@ -535,16 +535,16 @@ TEST_P(TDMOutput, OutputGetAvailablePropertiesNullObject) const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_available_properties(NULL, &props, &count) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(props == (const tdm_prop *)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(count == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_available_properties(NULL, &props, &count), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(props, (const tdm_prop *)TDM_UT_INVALID_VALUE); + ASSERT_EQ(count, TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetAvailablePropertiesNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_get_available_properties(outputs[0], NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_get_available_properties(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetAvailableModes) @@ -557,8 +557,8 @@ TEST_P(TDMOutput, OutputGetAvailableModes) int count = TDM_UT_INVALID_VALUE; const tdm_output_mode *modes_array = (const tdm_output_mode *) TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_available_modes(outputs[o], &modes_array, &count) == TDM_ERROR_NONE); - ASSERT_TRUE(count > 0); + ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes_array, &count), TDM_ERROR_NONE); + ASSERT_GT(count, 0); ASSERT_TRUE(modes_array != NULL && modes_array != (const tdm_output_mode *)TDM_UT_INVALID_VALUE); } } @@ -569,16 +569,16 @@ TEST_P(TDMOutput, OutputGetAvailableModesNullObject) int count = TDM_UT_INVALID_VALUE; const tdm_output_mode *modes_array = (const tdm_output_mode *) TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_available_modes(NULL, &modes_array, &count) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(count == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(modes_array == (const tdm_output_mode *) TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_available_modes(NULL, &modes_array, &count), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(count, TDM_UT_INVALID_VALUE); + ASSERT_EQ(modes_array, (const tdm_output_mode *) TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetAvailableModesNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_get_available_modes(outputs[0], NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_get_available_modes(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetAvailableSize) @@ -592,12 +592,12 @@ TEST_P(TDMOutput, OutputGetAvailableSize) int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE; int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE; int preferred_align = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align) == TDM_ERROR_NONE); - ASSERT_TRUE(min_w != TDM_UT_INVALID_VALUE); - ASSERT_TRUE(min_h != TDM_UT_INVALID_VALUE); - ASSERT_TRUE(max_w != TDM_UT_INVALID_VALUE); - ASSERT_TRUE(max_h != TDM_UT_INVALID_VALUE); - ASSERT_TRUE(preferred_align != TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE); + ASSERT_NE(min_w, TDM_UT_INVALID_VALUE); + ASSERT_NE(min_h, TDM_UT_INVALID_VALUE); + ASSERT_NE(max_w, TDM_UT_INVALID_VALUE); + ASSERT_NE(max_h, TDM_UT_INVALID_VALUE); + ASSERT_NE(preferred_align, TDM_UT_INVALID_VALUE); } } @@ -608,19 +608,19 @@ TEST_P(TDMOutput, OutputGetAvailableSizeNullObject) int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE; int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE; int preferred_align = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(min_w == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(min_h == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(max_w == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(max_h == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(preferred_align == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE); + ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE); + ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE); + ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE); + ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetAvailableSizeNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_get_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE); } TEST_P(TDMOutput, OutputGetCursorAvailableSize) @@ -630,18 +630,18 @@ TEST_P(TDMOutput, OutputGetCursorAvailableSize) int major = TDM_UT_INVALID_VALUE; int minor = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE); if (major > 1 || (major >= 1 && minor >= 5)) { for (int o = 0; o < output_count; o++) { int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE; int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE; int preferred_align = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align) == TDM_ERROR_NONE); - ASSERT_TRUE(min_w != TDM_UT_INVALID_VALUE); - ASSERT_TRUE(min_h != TDM_UT_INVALID_VALUE); - ASSERT_TRUE(max_w != TDM_UT_INVALID_VALUE); - ASSERT_TRUE(max_h != TDM_UT_INVALID_VALUE); - ASSERT_TRUE(preferred_align != TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE); + ASSERT_NE(min_w, TDM_UT_INVALID_VALUE); + ASSERT_NE(min_h, TDM_UT_INVALID_VALUE); + ASSERT_NE(max_w, TDM_UT_INVALID_VALUE); + ASSERT_NE(max_h, TDM_UT_INVALID_VALUE); + ASSERT_NE(preferred_align, TDM_UT_INVALID_VALUE); } } } @@ -653,18 +653,18 @@ TEST_P(TDMOutput, OutputGetCursorAvailableSizeNullObject) int major = TDM_UT_INVALID_VALUE; int minor = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE); if (major > 1 || (major >= 1 && minor >= 5)) { for (int o = 0; o < output_count; o++) { int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE; int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE; int preferred_align = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_cursor_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(min_w == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(min_h == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(max_w == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(max_h == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(preferred_align == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_cursor_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE); + ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE); + ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE); + ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE); + ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE); } } } @@ -676,9 +676,9 @@ TEST_P(TDMOutput, OutputGetCursorAvailableSizeNullOther) int major = TDM_UT_INVALID_VALUE; int minor = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE); if (major > 1 || (major >= 1 && minor >= 5)) - ASSERT_TRUE(tdm_output_get_cursor_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_cursor_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE); } TEST_P(TDMOutput, OutputGetCursorAvailableSizeNoMatchVersion) @@ -688,18 +688,18 @@ TEST_P(TDMOutput, OutputGetCursorAvailableSizeNoMatchVersion) int major = TDM_UT_INVALID_VALUE; int minor = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE); if (major <= 1 && minor < 5) { for (int o = 0; o < output_count; o++) { int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE; int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE; int preferred_align = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align) == TDM_ERROR_BAD_REQUEST); - ASSERT_TRUE(min_w == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(min_h == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(max_w == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(max_h == TDM_UT_INVALID_VALUE); - ASSERT_TRUE(preferred_align == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE); + ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE); + ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE); + ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE); + ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE); } } } @@ -711,9 +711,9 @@ TEST_P(TDMOutput, OutputGetPhysicalSize) for (int o = 0; o < output_count; o++) { unsigned int mmWidth = (unsigned int)TDM_UT_INVALID_VALUE; unsigned int mmHeight = (unsigned int)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_physical_size(outputs[o], &mmWidth, &mmHeight) == TDM_ERROR_NONE); - ASSERT_TRUE(mmWidth != (unsigned int)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(mmHeight != (unsigned int)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_physical_size(outputs[o], &mmWidth, &mmHeight), TDM_ERROR_NONE); + ASSERT_NE(mmWidth, (unsigned int)TDM_UT_INVALID_VALUE); + ASSERT_NE(mmHeight, (unsigned int)TDM_UT_INVALID_VALUE); } } @@ -723,16 +723,16 @@ TEST_P(TDMOutput, OutputGetPhysicalSizeNullObject) unsigned int mmWidth = (unsigned int)TDM_UT_INVALID_VALUE; unsigned int mmHeight = (unsigned int)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_physical_size(NULL, &mmWidth, &mmHeight) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(mmWidth == (unsigned int)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(mmHeight == (unsigned int)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_physical_size(NULL, &mmWidth, &mmHeight), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(mmWidth, (unsigned int)TDM_UT_INVALID_VALUE); + ASSERT_EQ(mmHeight, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetPhysicalSizeNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_get_physical_size(outputs[0], NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_physical_size(outputs[0], NULL, NULL), TDM_ERROR_NONE); } TEST_P(TDMOutput, OutputGetSubpixel) @@ -741,8 +741,8 @@ TEST_P(TDMOutput, OutputGetSubpixel) for (int o = 0; o < output_count; o++) { unsigned int subpixel = (unsigned int)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_subpixel(outputs[o], &subpixel) == TDM_ERROR_NONE); - ASSERT_TRUE(subpixel != (unsigned int)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_subpixel(outputs[o], &subpixel), TDM_ERROR_NONE); + ASSERT_NE(subpixel, (unsigned int)TDM_UT_INVALID_VALUE); } } @@ -751,15 +751,15 @@ TEST_P(TDMOutput, OutputGetSubpixelNullObject) TDM_UT_SKIP_FLAG(has_outputs); unsigned int subpixel = (unsigned int)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_subpixel(NULL, &subpixel) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(subpixel == (unsigned int)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_subpixel(NULL, &subpixel), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(subpixel, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetSubpixelNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_get_subpixel(outputs[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_get_subpixel(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetPipe) @@ -768,8 +768,8 @@ TEST_P(TDMOutput, OutputGetPipe) for (int o = 0; o < output_count; o++) { unsigned int pipe = (unsigned int)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_pipe(outputs[o], &pipe) == TDM_ERROR_NONE); - ASSERT_TRUE(pipe != (unsigned int)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_pipe(outputs[o], &pipe), TDM_ERROR_NONE); + ASSERT_NE(pipe, (unsigned int)TDM_UT_INVALID_VALUE); } } @@ -778,15 +778,15 @@ TEST_P(TDMOutput, OutputGetPipeNullObject) TDM_UT_SKIP_FLAG(has_outputs); unsigned int pipe = (unsigned int)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_pipe(NULL, &pipe) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(pipe == (unsigned int)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_pipe(NULL, &pipe), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(pipe, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetPipeNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_get_pipe(outputs[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_get_pipe(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetPrimaryIndex) @@ -795,8 +795,8 @@ TEST_P(TDMOutput, OutputGetPrimaryIndex) for (int o = 0; o < output_count; o++) { int primary_index = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_primary_index(outputs[o], &primary_index) == TDM_ERROR_NONE); - ASSERT_TRUE(primary_index != TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_primary_index(outputs[o], &primary_index), TDM_ERROR_NONE); + ASSERT_NE(primary_index, TDM_UT_INVALID_VALUE); } } @@ -805,15 +805,15 @@ TEST_P(TDMOutput, OutputGetPrimaryIndexNullObject) TDM_UT_SKIP_FLAG(has_outputs); int primary_index = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_primary_index(NULL, &primary_index) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(primary_index == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_primary_index(NULL, &primary_index), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(primary_index, TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetPrimaryIndexNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_get_primary_index(outputs[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_get_primary_index(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputSetProperty) @@ -825,11 +825,11 @@ TEST_P(TDMOutput, OutputSetProperty) int count = TDM_UT_INVALID_VALUE; tdm_value value = {.s32 = 0}; - ASSERT_TRUE(tdm_output_get_available_properties(outputs[o], &props, &count) == TDM_ERROR_NONE); - ASSERT_TRUE(count >= 0); + ASSERT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE); + ASSERT_GE(count, 0); if (count > 0) { ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(tdm_output_set_property(outputs[o], props[0].id, value) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_property(outputs[o], props[0].id, value), TDM_ERROR_NONE); } } } @@ -838,7 +838,7 @@ TEST_P(TDMOutput, OutputSetPropertyNullObject) { tdm_value value = {.s32 = 0}; - ASSERT_TRUE(tdm_output_set_property(NULL, 0, value) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetProperty) @@ -848,15 +848,15 @@ TEST_P(TDMOutput, OutputGetProperty) for (int o = 0; o < output_count; o++) { int count = TDM_UT_INVALID_VALUE; const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_available_properties(outputs[o], &props, &count) == TDM_ERROR_NONE); - ASSERT_TRUE(count >= 0); + ASSERT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE); + ASSERT_GE(count, 0); if (count > 0) { ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE); for (int i = 0; i < count; i++) { tdm_value value = {.s32 = TDM_UT_INVALID_VALUE}; - ASSERT_TRUE(tdm_output_get_property(outputs[o], props[i].id, &value) == TDM_ERROR_NONE); - ASSERT_TRUE(value.s32 != TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_property(outputs[o], props[i].id, &value), TDM_ERROR_NONE); + ASSERT_NE(value.s32, TDM_UT_INVALID_VALUE); } } } @@ -867,15 +867,15 @@ TEST_P(TDMOutput, OutputGetPropertyNullObject) TDM_UT_SKIP_FLAG(has_outputs); tdm_value value = {.s32 = TDM_UT_INVALID_VALUE}; - ASSERT_TRUE(tdm_output_get_property(NULL, 0, &value) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(value.s32 == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_property(NULL, 0, &value), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(value.s32, TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetPropertyNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_get_property(outputs[0], 0, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_get_property(outputs[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER); } static void @@ -894,14 +894,14 @@ TEST_P(TDMOutput, OutputAddChangeHandler) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); done1 = false; - ASSERT_TRUE(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); - ASSERT_TRUE(done1 == true); + ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + ASSERT_EQ(done1, true); } } @@ -909,22 +909,22 @@ TEST_P(TDMOutput, OutputAddChangeHandlerTwice) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_add_change_handler(outputs[0], _ut_tdm_output_change_cb, NULL) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_add_change_handler(outputs[0], _ut_tdm_output_change_cb, NULL) == TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(tdm_output_add_change_handler(outputs[0], _ut_tdm_output_change_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_add_change_handler(outputs[0], _ut_tdm_output_change_cb, NULL), TDM_ERROR_BAD_REQUEST); } TEST_P(TDMOutput, OutputAddChangeHandlerNullObject) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_add_change_handler(NULL, _ut_tdm_output_change_cb, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_add_change_handler(NULL, _ut_tdm_output_change_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputAddChangeHandlerNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_add_change_handler(outputs[0], NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_add_change_handler(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputRemoveChangeHandler) @@ -933,7 +933,7 @@ TEST_P(TDMOutput, OutputRemoveChangeHandler) for (int o = 0; o < output_count; o++) { for (int t = 0; t < 10; t++) { - ASSERT_TRUE(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, NULL), TDM_ERROR_NONE); tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, NULL); } } @@ -947,14 +947,14 @@ TEST_P(TDMOutput, OutputRemoveChangeHandlerDifferentData) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); done1 = false; - ASSERT_TRUE(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1), TDM_ERROR_NONE); tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, NULL); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); - ASSERT_TRUE(done1 == true); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + ASSERT_EQ(done1, true); } } @@ -975,22 +975,22 @@ TEST_P(TDMOutput, OutputRemoveChangeHandlerInHandler) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); done1 = false; - ASSERT_TRUE(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb2, &done1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); - ASSERT_TRUE(done1 == true); + ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb2, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + ASSERT_EQ(done1, true); done2 = false; - ASSERT_TRUE(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done2) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); - ASSERT_TRUE(done2 == true); + ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + ASSERT_EQ(done2, true); done3 = false; - ASSERT_TRUE(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb2, &done3) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); - ASSERT_TRUE(done3 == true); + ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb2, &done3), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + ASSERT_EQ(done3, true); } } @@ -1018,12 +1018,12 @@ TEST_P(TDMOutput, OutputSetMode) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(tdm_output_get_available_modes(outputs[o], &modes, &count) == TDM_ERROR_NONE); - ASSERT_TRUE(modes != NULL); - ASSERT_TRUE(count > 0); + ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE); + ASSERT_NE(modes, NULL); + ASSERT_GT(count, 0); for (int m = 0; m < count; m++) - ASSERT_TRUE(tdm_output_set_mode(outputs[o], modes + m) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_mode(outputs[o], modes + m), TDM_ERROR_NONE); } } @@ -1032,7 +1032,7 @@ TEST_P(TDMOutput, OutputSetModeNullObject) TDM_UT_SKIP_FLAG(has_outputs); const tdm_output_mode *mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_set_mode(NULL, mode) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_set_mode(NULL, mode), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputSetModeNullOther) @@ -1043,7 +1043,7 @@ TEST_P(TDMOutput, OutputSetModeNullOther) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(tdm_output_set_mode(outputs[o], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_set_mode(outputs[o], NULL), TDM_ERROR_INVALID_PARAMETER); } } @@ -1058,15 +1058,15 @@ TEST_P(TDMOutput, OutputGetMode) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(tdm_output_get_available_modes(outputs[o], &modes, &count) == TDM_ERROR_NONE); - ASSERT_TRUE(modes != NULL); - ASSERT_TRUE(count > 0); + ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE); + ASSERT_NE(modes, NULL); + ASSERT_GT(count, 0); for (int m = 0; m < count; m++) { const tdm_output_mode *current_mode; - ASSERT_TRUE(tdm_output_set_mode(outputs[o], modes + m) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_get_mode(outputs[o], ¤t_mode) == TDM_ERROR_NONE); - ASSERT_TRUE(current_mode == modes + m); + ASSERT_EQ(tdm_output_set_mode(outputs[o], modes + m), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_mode(outputs[o], ¤t_mode), TDM_ERROR_NONE); + ASSERT_EQ(current_mode, modes + m); } } } @@ -1076,15 +1076,15 @@ TEST_P(TDMOutput, OutputGetModeNullObject) TDM_UT_SKIP_FLAG(has_outputs); const tdm_output_mode *current_mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_mode(NULL, ¤t_mode) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(current_mode == (const tdm_output_mode *)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_mode(NULL, ¤t_mode), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(current_mode, (const tdm_output_mode *)TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetModeNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_get_mode(outputs[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_get_mode(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetModeNoSet) @@ -1093,8 +1093,8 @@ TEST_P(TDMOutput, OutputGetModeNoSet) for (int o = 0; o < output_count; o++) { const tdm_output_mode *mode; - ASSERT_TRUE(tdm_output_get_mode(outputs[o], &mode) == TDM_ERROR_NONE); - ASSERT_TRUE(mode == NULL); + ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); + ASSERT_EQ(mode, NULL); } } @@ -1106,14 +1106,14 @@ TEST_P(TDMOutput, OutputSetDpms) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); if (ut_tdm_output_is_aod_enable(outputs[o])) { - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE); } else { - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD) == TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST); } } } @@ -1122,15 +1122,15 @@ TEST_P(TDMOutput, OutputSetDpmsNullObject) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_set_dpms(NULL, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_set_dpms(NULL, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputSetDpmsNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)-1) == TDM_ERROR_BAD_REQUEST); - ASSERT_TRUE(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)INT_MAX) == TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)-1), TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)INT_MAX), TDM_ERROR_BAD_REQUEST); } TEST_P(TDMOutput, OutputSetDpmsAsync) @@ -1144,11 +1144,11 @@ TEST_P(TDMOutput, OutputSetDpmsAsync) continue; done1 = false; - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_set_dpms_async(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms_async(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); while (!done1) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1); } } @@ -1163,28 +1163,28 @@ TEST_P(TDMOutput, OutputGetDpms) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_get_dpms(outputs[o], &dpms_value) == TDM_ERROR_NONE); - ASSERT_TRUE(dpms_value == TDM_OUTPUT_DPMS_OFF); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE); + ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_OFF); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_get_dpms(outputs[o], &dpms_value) == TDM_ERROR_NONE); - ASSERT_TRUE(dpms_value == TDM_OUTPUT_DPMS_STANDBY); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE); + ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_STANDBY); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_get_dpms(outputs[o], &dpms_value) == TDM_ERROR_NONE); - ASSERT_TRUE(dpms_value == TDM_OUTPUT_DPMS_SUSPEND); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE); + ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_SUSPEND); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_get_dpms(outputs[o], &dpms_value) == TDM_ERROR_NONE); - ASSERT_TRUE(dpms_value == TDM_OUTPUT_DPMS_ON); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE); + ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_ON); if (ut_tdm_output_is_aod_enable(outputs[o])) { - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_get_dpms(outputs[o], &dpms_value) == TDM_ERROR_NONE); - ASSERT_TRUE(dpms_value == TDM_OUTPUT_DPMS_AOD); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE); + ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_AOD); } else { - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD) == TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST); } } } @@ -1194,15 +1194,15 @@ TEST_P(TDMOutput, OutputGetDpmsNullObject) TDM_UT_SKIP_FLAG(has_outputs); tdm_output_dpms dpms_value = (tdm_output_dpms)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_dpms(NULL, &dpms_value) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(dpms_value == (tdm_output_dpms)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_dpms(NULL, &dpms_value), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(dpms_value, (tdm_output_dpms)TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetDpmsNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_get_dpms(outputs[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_get_dpms(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputWaitVblank) @@ -1213,7 +1213,7 @@ TEST_P(TDMOutput, OutputWaitVblank) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); for (int t = 0; t < 10; t++) { double start, end, interval; @@ -1222,13 +1222,13 @@ TEST_P(TDMOutput, OutputWaitVblank) done1 = false; start = tdm_helper_get_time(); - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], 1, 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); while (!done1) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) < (interval + interval)); + ASSERT_LT((end - start), (interval + interval)); } } } @@ -1237,7 +1237,7 @@ TEST_P(TDMOutput, OutputWaitVblankNullObject) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_wait_vblank(NULL, 1, 0, _ut_tdm_output_done_cb, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_wait_vblank(NULL, 1, 0, _ut_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputWaitVblankNullOther) @@ -1248,9 +1248,9 @@ TEST_P(TDMOutput, OutputWaitVblankNullOther) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], 1, 0, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, NULL, NULL), TDM_ERROR_NONE); } } @@ -1262,14 +1262,14 @@ TEST_P(TDMOutput, OutputWaitVblankTimeout) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], 1, 0, _ut_tdm_output_done_cb, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _ut_tdm_output_done_cb, NULL), TDM_ERROR_NONE); usleep(1100000); - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_helper_output_vblank_timer_expired(outputs[o]) > 0); + ASSERT_GT(tdm_helper_output_vblank_timer_expired(outputs[o]), 0); } } @@ -1277,7 +1277,7 @@ TEST_P(TDMOutput, OutputWaitVblankInterval0) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_wait_vblank(outputs[0], 0, 0, _ut_tdm_output_done_cb, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_wait_vblank(outputs[0], 0, 0, _ut_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputWaitVblankInterval) @@ -1288,7 +1288,7 @@ TEST_P(TDMOutput, OutputWaitVblankInterval) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); /* start from 1 */ for (int t = 1; t < 10; t++) { @@ -1298,14 +1298,14 @@ TEST_P(TDMOutput, OutputWaitVblankInterval) done1 = false; start = tdm_helper_get_time(); - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); while (!done1) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) > (interval * (t - 1))); - ASSERT_TRUE((end - start) < (interval * t + interval)); + ASSERT_GT((end - start), (interval * (t - 1))); + ASSERT_LT((end - start), (interval * t + interval)); } } } @@ -1318,7 +1318,7 @@ TEST_P(TDMOutput, OutputWaitVblankFewTimesInOneVblank) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); /* start from 1 */ for (int t = 1; t < 10; t++) { @@ -1327,18 +1327,18 @@ TEST_P(TDMOutput, OutputWaitVblankFewTimesInOneVblank) interval = ut_tdm_output_get_vblank_interval_time(outputs[o]); done1 = done2 = done3 = false; - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done1 || !done2 || !done3) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) > (interval * (t - 1))); - ASSERT_TRUE((end - start) < (interval * t + interval)); + ASSERT_GT((end - start), (interval * (t - 1))); + ASSERT_LT((end - start), (interval * t + interval)); } } } @@ -1351,16 +1351,16 @@ TEST_P(TDMOutput, OutputWaitVblankBeforeDpmsOff) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], false) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], false), true); for (int t = 0; t < 10; t++) { bool done = false; - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], 1, 0, _ut_tdm_output_done_cb, &done) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _ut_tdm_output_done_cb, &done), TDM_ERROR_NONE); if (t == 9) - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); while(!done) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1373,17 +1373,17 @@ TEST_P(TDMOutput, OutputRemoveVblankHandler) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); /* start from 1 */ for (int t = 1; t < 10; t++) { done1 = done2 = done3 = false; - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE); tdm_output_remove_vblank_handler(outputs[o], _ut_tdm_output_done_cb, &done2); while (!done1 || done2 || !done3) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1401,12 +1401,12 @@ TEST_P(TDMOutput, OutputRemoveVblankHandlerDifferentData) /* start from 1 */ for (int t = 1; t < 10; t++) { done1 = done2 = done3 = false; - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE); tdm_output_remove_vblank_handler(outputs[o], _ut_tdm_output_done_cb, NULL); while (!done1 || !done2 || !done3) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1430,16 +1430,16 @@ TEST_P(TDMOutput, OutputRemoveVblankHandlerInHandler) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); /* start from 1 */ for (int t = 1; t < 10; t++) { done1 = done2 = done3 = false; - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE); while (!done1 || !done2 || !done3) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1456,7 +1456,7 @@ TEST_P(TDMOutput, OutputCommit) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); for (int t = 0; t < 10; t++) { double start, end, interval; @@ -1465,13 +1465,13 @@ TEST_P(TDMOutput, OutputCommit) done1 = false; start = tdm_helper_get_time(); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); while (!done1) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) < (interval + interval)); + ASSERT_LT((end - start), (interval + interval)); } } } @@ -1480,7 +1480,7 @@ TEST_P(TDMOutput, OutputCommitNullObject) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_output_commit(NULL, 0, _ut_tdm_output_done_cb, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_commit(NULL, 0, _ut_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputCommitNullOther) @@ -1495,8 +1495,8 @@ TEST_P(TDMOutput, OutputCommitNullOther) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); } } @@ -1512,11 +1512,11 @@ TEST_P(TDMOutput, OutputCommitDpmsSuspend) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, NULL) == TDM_ERROR_DPMS_OFF); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF); } } @@ -1532,11 +1532,11 @@ TEST_P(TDMOutput, OutputCommitDpmsOff) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, NULL) == TDM_ERROR_DPMS_OFF); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF); } } @@ -1555,15 +1555,15 @@ TEST_P(TDMOutput, OutputCommitDpmsAOD) if (!ut_tdm_output_is_aod_enable(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); - ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE); for (int t = 0; t < 10; t++) { done1 = false; - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); while (!done1) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1580,21 +1580,21 @@ TEST_P(TDMOutput, OutputCommitAfterLayerCommit) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); - ASSERT_TRUE(tdm_output_get_primary_index(outputs[o], &index) == TDM_ERROR_NONE); - ASSERT_TRUE(index != TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_output_get_primary_index(outputs[o], &index), TDM_ERROR_NONE); + ASSERT_NE(index, TDM_UT_INVALID_VALUE); layer = tdm_output_get_layer(outputs[o], index, &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(layer != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(layer, NULL); - ASSERT_TRUE(tdm_layer_commit(layer, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layer, NULL, NULL), TDM_ERROR_NONE); if (!tdm_helper_output_commit_per_vblank_enabled(outputs[o])) - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); else - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_BAD_REQUEST); } } @@ -1605,7 +1605,7 @@ TEST_P(TDMOutput, OutputCommitMismatchCommitType) for (int o = 0; o < output_count; o++) { if (!tdm_helper_output_commit_per_vblank_enabled(outputs[o])) continue; - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, NULL, NULL) == TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_BAD_REQUEST); } } @@ -1621,15 +1621,15 @@ TEST_P(TDMOutput, OutputCommitFewTimesInOneVblank) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); for (int t = 0; t < 10; t++) { done1 = done2 = done3 = false; - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done2) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done3) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE); while (!done1 || !done2 || !done3) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1652,16 +1652,16 @@ TEST_P(TDMOutput, OutputRemoveCommitHandler) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); for (int t = 0; t < 10; t++) { done1 = done2 = done3 = false; - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done2) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done3) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE); tdm_output_remove_commit_handler(outputs[o], _ut_tdm_output_done_cb, &done2); while (!done1 || done2 || !done3) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1678,16 +1678,16 @@ TEST_P(TDMOutput, OutputRemoveCommitHandlerDifferentData) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); for (int t = 0; t < 10; t++) { done1 = done2 = done3 = false; - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done2) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done3) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE); tdm_output_remove_commit_handler(outputs[o], _ut_tdm_output_done_cb, NULL); while (!done1 || !done2 || !done3) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1704,15 +1704,15 @@ TEST_P(TDMOutput, OutputRemoveCommitHandlerInHandler) if (!ut_tdm_output_is_connected(outputs[o])) continue; - ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o], true) == true); + ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); for (int t = 0; t < 10; t++) { done1 = done2 = done3 = false; - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb2, &done1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb2, &done2) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb2, &done3) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb2, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb2, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb2, &done3), TDM_ERROR_NONE); while (!done1 || !done2 || !done3) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } diff --git a/utests/src/ut_tdm_output_hwc.cpp b/utests/src/ut_tdm_output_hwc.cpp index 1695e6b..9b3e274 100644 --- a/utests/src/ut_tdm_output_hwc.cpp +++ b/utests/src/ut_tdm_output_hwc.cpp @@ -312,7 +312,7 @@ TEST_P(TDMHwcWindow, GetChangedCompositionTypesSuccessful) error = tdm_output_hwc_get_changed_composition_types(outputs[o], &get_num, NULL, NULL); ASSERT_EQ(TDM_ERROR_NONE, error); - ASSERT_TRUE(get_num == validate_num); + ASSERT_EQ(get_num, validate_num); hwc_wnds = (tdm_hwc_window **)calloc(get_num, sizeof(tdm_hwc_window *)); composition_types = (tdm_hwc_window_composition *)calloc(get_num, sizeof(tdm_hwc_window_composition)); diff --git a/utests/src/ut_tdm_vblank.cpp b/utests/src/ut_tdm_vblank.cpp index a7bf51c..e72372e 100644 --- a/utests/src/ut_tdm_vblank.cpp +++ b/utests/src/ut_tdm_vblank.cpp @@ -182,8 +182,8 @@ TEST_P(TDMVblank, DISABLED_VblankSetClientVblankFps) TEST_P(TDMVblank, VblankSetClientVblankFpsNullObject) { - ASSERT_TRUE(tdm_vblank_set_client_vblank_fps(0, NULL, 60) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(tdm_vblank_set_client_vblank_fps(123, NULL, 0) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_set_client_vblank_fps(0, NULL, 60), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_set_client_vblank_fps(123, NULL, 0), TDM_ERROR_INVALID_PARAMETER); } /* tdm_vblank_set_client_vblank_fps */ @@ -194,8 +194,8 @@ TEST_P(TDMVblank, DISABLED_VblankSetClientIgnoreGlobalFps) TEST_P(TDMVblank, VblankSetClientIgnoreGlobalFpsNullObject) { - ASSERT_TRUE(tdm_vblank_set_client_ignore_global_fps(0, NULL, 0) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(tdm_vblank_set_client_ignore_global_fps(0, NULL, 1) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_set_client_ignore_global_fps(0, NULL, 0), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_set_client_ignore_global_fps(0, NULL, 1), TDM_ERROR_INVALID_PARAMETER); } /* tdm_vblank_create() */ @@ -206,8 +206,8 @@ TEST_P(TDMVblank, VblankCreateDestroy) for (int o = 0; o < output_count; o++) { tdm_error ret; tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(vblank != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(vblank, NULL); tdm_vblank_destroy(vblank); } @@ -220,8 +220,8 @@ TEST_P(TDMVblank, VblankCreateNullDpy) tdm_error ret; tdm_vblank *vblank = tdm_vblank_create(NULL, outputs[0], &ret); - ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(vblank == NULL); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(vblank, NULL); } TEST_P(TDMVblank, VblankCreateNullOutput) @@ -229,8 +229,8 @@ TEST_P(TDMVblank, VblankCreateNullOutput) tdm_error ret; tdm_vblank *vblank = tdm_vblank_create(dpy, NULL, &ret); - ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(vblank == NULL); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(vblank, NULL); } TEST_P(TDMVblank, VblankCreateNullOther) @@ -238,7 +238,7 @@ TEST_P(TDMVblank, VblankCreateNullOther) TDM_UT_SKIP_FLAG(has_outputs); tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[0], NULL); - ASSERT_TRUE(vblank != NULL); + ASSERT_NE(vblank, NULL); tdm_vblank_destroy(vblank); } @@ -262,7 +262,7 @@ TEST_P(TDMVblank, VblankAddCreateHandler) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE); for (int o = 0; o < output_count; o++) { tdm_error ret; @@ -270,9 +270,9 @@ TEST_P(TDMVblank, VblankAddCreateHandler) done = false; tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(vblank != NULL); - ASSERT_TRUE(done == true); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(vblank, NULL); + ASSERT_EQ(done, true); tdm_vblank_destroy(vblank); } @@ -282,22 +282,22 @@ TEST_P(TDMVblank, VblankAddCreateHandlerTwice) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL) == TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL), TDM_ERROR_BAD_REQUEST); } TEST_P(TDMVblank, VblankAddCreateHandlerNullObject) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_vblank_add_create_handler(NULL, _ut_tdm_vblank_create_cb, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_add_create_handler(NULL, _ut_tdm_vblank_create_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankAddCreateHandlerNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_vblank_add_create_handler(dpy, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_add_create_handler(dpy, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } /* tdm_vblank_remove_create_handler */ @@ -305,7 +305,7 @@ TEST_P(TDMVblank, VblankRemoveCreateHandler) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE); tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this); for (int o = 0; o < output_count; o++) { @@ -314,9 +314,9 @@ TEST_P(TDMVblank, VblankRemoveCreateHandler) done = false; tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(vblank != NULL); - ASSERT_TRUE(done == false); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(vblank, NULL); + ASSERT_EQ(done, false); tdm_vblank_destroy(vblank); } @@ -326,7 +326,7 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerFewTimes) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE); tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this); tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this); @@ -338,9 +338,9 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerFewTimes) done = false; tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(vblank != NULL); - ASSERT_TRUE(done == false); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(vblank, NULL); + ASSERT_EQ(done, false); tdm_vblank_destroy(vblank); } @@ -350,7 +350,7 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerDifferentData) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE); tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL); @@ -360,9 +360,9 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerDifferentData) done = false; tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(vblank != NULL); - ASSERT_TRUE(done == true); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(vblank, NULL); + ASSERT_EQ(done, true); tdm_vblank_destroy(vblank); } @@ -380,7 +380,7 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerInHandler) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb2, this) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb2, this), TDM_ERROR_NONE); for (int o = 0; o < output_count; o++) { tdm_error ret; @@ -388,12 +388,12 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerInHandler) done = false; tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(vblank != NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(vblank, NULL); if (o == 0) - ASSERT_TRUE(done == true); + ASSERT_EQ(done, true); else - ASSERT_TRUE(done == false); + ASSERT_EQ(done, false); tdm_vblank_destroy(vblank); } @@ -418,29 +418,29 @@ TEST_P(TDMVblank, VblankGetOutput) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { tdm_error ret; - ASSERT_TRUE(tdm_vblank_get_output(vblanks[v], &ret) != NULL); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_NE(tdm_vblank_get_output(vblanks[v], &ret), NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); } } TEST_P(TDMVblank, VblankGetOutputNullObject) { tdm_error ret; - ASSERT_TRUE(tdm_vblank_get_output(NULL, &ret) == NULL); - ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_get_output(NULL, &ret), NULL); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankGetOutputNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); - ASSERT_TRUE(tdm_vblank_get_output(vblanks[0], NULL) != NULL); + ASSERT_NE(tdm_vblank_get_output(vblanks[0], NULL), NULL); } /* tdm_vblank_get_client_pid() */ @@ -448,30 +448,30 @@ TEST_P(TDMVblank, VblankGetClientPid) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { pid_t pid = (pid_t)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_vblank_get_client_pid(vblanks[v], &pid) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_client_pid(vblanks[v], &pid), TDM_ERROR_NONE); /* client pid should be 0 in case vblank is created in server side */ - ASSERT_TRUE(pid == 0); + ASSERT_EQ(pid, 0); } } TEST_P(TDMVblank, VblankGetClientPidNullObject) { pid_t pid = (pid_t)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_vblank_get_client_pid(NULL, &pid) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(pid == (pid_t)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_vblank_get_client_pid(NULL, &pid), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(pid, (pid_t)TDM_UT_INVALID_VALUE); } TEST_P(TDMVblank, VblankGetClientPidNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); - ASSERT_TRUE(tdm_vblank_get_client_pid(vblanks[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_get_client_pid(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER); } /* tdm_vblank_set_name() */ @@ -479,25 +479,25 @@ TEST_P(TDMVblank, VblankSetName) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) - ASSERT_TRUE(tdm_vblank_set_name(vblanks[v], TDM_UT_VBLANK_NAME) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_name(vblanks[v], TDM_UT_VBLANK_NAME), TDM_ERROR_NONE); } TEST_P(TDMVblank, VblankSetNameNullObject) { - ASSERT_TRUE(tdm_vblank_set_name(NULL, TDM_UT_VBLANK_NAME) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_set_name(NULL, TDM_UT_VBLANK_NAME), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankSetNameNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) - ASSERT_TRUE(tdm_vblank_set_name(vblanks[v], NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_name(vblanks[v], NULL), TDM_ERROR_NONE); } /* tdm_vblank_get_name() */ @@ -505,12 +505,12 @@ TEST_P(TDMVblank, VblankGetName) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { const char *name = (const char *)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_vblank_set_name(vblanks[v], TDM_UT_VBLANK_NAME) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_get_name(vblanks[v], &name) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_name(vblanks[v], TDM_UT_VBLANK_NAME), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_name(vblanks[v], &name), TDM_ERROR_NONE); ASSERT_STREQ(name, TDM_UT_VBLANK_NAME); } } @@ -518,28 +518,28 @@ TEST_P(TDMVblank, VblankGetName) TEST_P(TDMVblank, VblankGetNameNullObject) { const char *name = (const char *)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_vblank_get_name(NULL, &name) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(name == (const char *)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_vblank_get_name(NULL, &name), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(name, (const char *)TDM_UT_INVALID_VALUE); } TEST_P(TDMVblank, VblankGetNameNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); - ASSERT_TRUE(tdm_vblank_get_name(vblanks[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_get_name(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankGetNameNoSet) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { const char *name = (const char *)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_vblank_get_name(vblanks[v], &name) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_name(vblanks[v], &name), TDM_ERROR_NONE); ASSERT_STREQ(name, TDM_VBLANK_DEFAULT_NAME); } } @@ -549,26 +549,26 @@ TEST_P(TDMVblank, VblankSetFps) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) - ASSERT_TRUE(tdm_vblank_set_fps(vblanks[v], 60) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE); } TEST_P(TDMVblank, VblankSetFpsNullObject) { - ASSERT_TRUE(tdm_vblank_set_fps(NULL, 60) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_set_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankSetFpsTwice) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { - ASSERT_TRUE(tdm_vblank_set_fps(vblanks[v], 60) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_set_fps(vblanks[v], 60) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE); } } @@ -577,26 +577,26 @@ TEST_P(TDMVblank, VblankSetFixedFps) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) - ASSERT_TRUE(tdm_vblank_set_fixed_fps(vblanks[v], 60) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE); } TEST_P(TDMVblank, VblankSetFixedFpsNullObject) { - ASSERT_TRUE(tdm_vblank_set_fixed_fps(NULL, 60) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_set_fixed_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankSetFixedFpsTwice) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { - ASSERT_TRUE(tdm_vblank_set_fixed_fps(vblanks[v], 60) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_set_fixed_fps(vblanks[v], 60) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE); } } @@ -605,38 +605,38 @@ TEST_P(TDMVblank, VblankGetFps) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_vblank_set_fps(vblanks[v], 60) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == TDM_ERROR_NONE); - ASSERT_TRUE(fps == 60); + ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); + ASSERT_EQ(fps, 60); } } TEST_P(TDMVblank, VblankGetFpsNullObject) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_vblank_get_fps(NULL, &fps) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(fps == (unsigned int)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_vblank_get_fps(NULL, &fps), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(fps, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMVblank, VblankGetFpsNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); - ASSERT_TRUE(tdm_vblank_get_fps(vblanks[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankGetFpsNoSet) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestPrepareOutput() == true); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestPrepareOutput(), true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; @@ -646,17 +646,17 @@ TEST_P(TDMVblank, VblankGetFpsNoSet) if (!ut_tdm_vblank_is_avaiable(vblanks[v])) continue; - ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); ASSERT_TRUE(fps != 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret); - ASSERT_TRUE(output != NULL); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_NE(output, NULL); + ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); ASSERT_TRUE(mode != NULL && mode != (const tdm_output_mode *)TDM_UT_INVALID_VALUE); - ASSERT_TRUE(fps == mode->vrefresh); + ASSERT_EQ(fps, mode->vrefresh); } } @@ -664,54 +664,54 @@ TEST_P(TDMVblank, VblankGetFpsAfterSetFixedFps) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_vblank_set_fps(vblanks[v], 60) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == TDM_ERROR_NONE); - ASSERT_TRUE(fps == 60); + ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); + ASSERT_EQ(fps, 60); - ASSERT_TRUE(tdm_vblank_set_fixed_fps(vblanks[v], 10) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == TDM_ERROR_NONE); - ASSERT_TRUE(fps == 10); + ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); + ASSERT_EQ(fps, 10); /* should return TDM_ERROR_NONE because tdm_vblank_set_fixed_fps would be * called by other who call tdm_vblank_set_fps. If returns error, other * can't handle error. */ - ASSERT_TRUE(tdm_vblank_set_fps(vblanks[v], 60) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == TDM_ERROR_NONE); - ASSERT_TRUE(fps == 10); + ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); + ASSERT_EQ(fps, 10); } } /* tdm_vblank_ignore_global_fps() */ TEST_P(TDMVblank, VblankIgnoreGlobalFpsNullObject) { - ASSERT_TRUE(tdm_vblank_ignore_global_fps(NULL, 1) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_ignore_global_fps(NULL, 1), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankIgnoreGlobalFpsSet) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) - ASSERT_TRUE(tdm_vblank_ignore_global_fps(vblanks[v], 1) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE); } TEST_P(TDMVblank, VblankIgnoreGlobalFpsSetTwice) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { - ASSERT_TRUE(tdm_vblank_ignore_global_fps(vblanks[v], 1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_ignore_global_fps(vblanks[v], 1) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE); } } @@ -719,21 +719,21 @@ TEST_P(TDMVblank, VblankIgnoreGlobalFpsUnset) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) - ASSERT_TRUE(tdm_vblank_ignore_global_fps(vblanks[v], 0) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE); } TEST_P(TDMVblank, VblankIgnoreGlobalFpsUnsetTwice) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { - ASSERT_TRUE(tdm_vblank_ignore_global_fps(vblanks[v], 0) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_ignore_global_fps(vblanks[v], 0) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE); } } @@ -742,26 +742,26 @@ TEST_P(TDMVblank, VblankSetOffset) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) - ASSERT_TRUE(tdm_vblank_set_offset(vblanks[v], 10) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE); } TEST_P(TDMVblank, VblankSetOffsetNullObject) { - ASSERT_TRUE(tdm_vblank_set_offset(NULL, 10) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankSetOffsetTwice) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { - ASSERT_TRUE(tdm_vblank_set_offset(vblanks[v], 10) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_set_offset(vblanks[v], 10) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE); } } @@ -770,42 +770,42 @@ TEST_P(TDMVblank, VblankGetOffset) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { int offset = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_vblank_set_offset(vblanks[v], 10) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_get_offset(vblanks[v], &offset) == TDM_ERROR_NONE); - ASSERT_TRUE(offset == 10); + ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_offset(vblanks[v], &offset), TDM_ERROR_NONE); + ASSERT_EQ(offset, 10); } } TEST_P(TDMVblank, VblankGetOffsetNullObject) { int offset = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_vblank_get_offset(NULL, &offset) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(offset == TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_vblank_get_offset(NULL, &offset), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(offset, TDM_UT_INVALID_VALUE); } TEST_P(TDMVblank, VblankGetOffsetNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); - ASSERT_TRUE(tdm_vblank_get_offset(vblanks[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_get_offset(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankGetOffsetNoSet) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { int offset = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_vblank_get_offset(vblanks[v], &offset) == TDM_ERROR_NONE); - ASSERT_TRUE(offset == 0); + ASSERT_EQ(tdm_vblank_get_offset(vblanks[v], &offset), TDM_ERROR_NONE); + ASSERT_EQ(offset, 0); } } @@ -814,26 +814,26 @@ TEST_P(TDMVblank, VblankSetEnableFake) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) - ASSERT_TRUE(tdm_vblank_set_enable_fake(vblanks[v], 1) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE); } TEST_P(TDMVblank, VblankSetEnableFakeNullObject) { - ASSERT_TRUE(tdm_vblank_set_enable_fake(NULL, 1) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankSetEnableFakeTwice) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { - ASSERT_TRUE(tdm_vblank_set_enable_fake(vblanks[v], 1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_set_enable_fake(vblanks[v], 1) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE); } } @@ -842,46 +842,46 @@ TEST_P(TDMVblank, VblankGetEnableFake) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int enable_fake; - ASSERT_TRUE(tdm_vblank_set_enable_fake(vblanks[v], 1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake) == TDM_ERROR_NONE); - ASSERT_TRUE(enable_fake == 1); + ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE); + ASSERT_EQ(enable_fake, 1); - ASSERT_TRUE(tdm_vblank_set_enable_fake(vblanks[v], 0) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake) == TDM_ERROR_NONE); - ASSERT_TRUE(enable_fake == 0); + ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 0), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE); + ASSERT_EQ(enable_fake, 0); } } TEST_P(TDMVblank, VblankGetEnableFakeNullObject) { unsigned int enable_fake = (unsigned int)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_vblank_get_enable_fake(NULL, &enable_fake) == TDM_ERROR_INVALID_PARAMETER); - ASSERT_TRUE(enable_fake == (unsigned int)TDM_UT_INVALID_VALUE); + ASSERT_EQ(tdm_vblank_get_enable_fake(NULL, &enable_fake), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(enable_fake, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMVblank, VblankGetEnableFakeNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); - ASSERT_TRUE(tdm_vblank_get_enable_fake(vblanks[0], NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankGetEnableFakeNoSet) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int enable_fake; - ASSERT_TRUE(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake) == TDM_ERROR_NONE); - ASSERT_TRUE(enable_fake == 0); + ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE); + ASSERT_EQ(enable_fake, 0); } } @@ -898,8 +898,8 @@ TEST_P(TDMVblank, VblankWait) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestPrepareOutput() == true); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestPrepareOutput(), true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; @@ -908,7 +908,7 @@ TEST_P(TDMVblank, VblankWait) if (!ut_tdm_vblank_is_avaiable(vblanks[v])) continue; - ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); interval = 1.0 / (double)fps; @@ -916,13 +916,13 @@ TEST_P(TDMVblank, VblankWait) unsigned int cur_seq = 0; start = tdm_helper_get_time(); - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) < (interval + interval)); + ASSERT_LT((end - start), (interval + interval)); } } } @@ -931,8 +931,8 @@ TEST_P(TDMVblank, VblankWaitFewTime) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestPrepareOutput() == true); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestPrepareOutput(), true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; @@ -941,7 +941,7 @@ TEST_P(TDMVblank, VblankWaitFewTime) if (!ut_tdm_vblank_is_avaiable(vblanks[v])) continue; - ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); interval = 1.0 / (double)fps; @@ -950,18 +950,18 @@ TEST_P(TDMVblank, VblankWaitFewTime) cur_seq = seq1 = seq2 = 0; start = tdm_helper_get_time(); - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &seq1) == TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &seq2) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &seq1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &seq2), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); - ASSERT_TRUE(seq1 != 0); - ASSERT_TRUE(seq2 != 0); + ASSERT_NE(seq1, 0); + ASSERT_NE(seq2, 0); /* "+ interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) < (interval + interval)); + ASSERT_LT((end - start), (interval + interval)); } } } @@ -970,18 +970,18 @@ TEST_P(TDMVblank, VblankWaitInterval0) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestPrepareOutput() == true); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestPrepareOutput(), true); + ASSERT_EQ(TestCreateVblanks(), true); - ASSERT_TRUE(tdm_vblank_wait(vblanks[0], 0, 0, 0, _ut_tdm_vblank_cb, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, _ut_tdm_vblank_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankWaitInterval) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestPrepareOutput() == true); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestPrepareOutput(), true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; @@ -990,7 +990,7 @@ TEST_P(TDMVblank, VblankWaitInterval) if (!ut_tdm_vblank_is_avaiable(vblanks[v])) continue; - ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); interval = 1.0 / (double)fps; @@ -999,14 +999,14 @@ TEST_P(TDMVblank, VblankWaitInterval) unsigned int cur_seq = 0; start = tdm_helper_get_time(); - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, t, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, t, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) > interval * (t - 1)); - ASSERT_TRUE((end - start) < interval * t + interval); + ASSERT_GT((end - start), interval * (t - 1)); + ASSERT_LT((end - start), interval * t + interval); } } } @@ -1015,8 +1015,8 @@ TEST_P(TDMVblank, VblankWaitSeq) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestPrepareOutput() == true); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestPrepareOutput(), true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; @@ -1025,25 +1025,25 @@ TEST_P(TDMVblank, VblankWaitSeq) if (!ut_tdm_vblank_is_avaiable(vblanks[v])) continue; - ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); interval = 1.0 / (double)fps; for (int t = 0; t < 10; t++) { unsigned int cur_seq = 0, temp = 0; - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); start = tdm_helper_get_time(); - ASSERT_TRUE(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + 1, _ut_tdm_vblank_cb, &temp) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + 1, _ut_tdm_vblank_cb, &temp), TDM_ERROR_NONE); while (temp == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) < (interval + interval)); + ASSERT_LT((end - start), (interval + interval)); } } } @@ -1052,8 +1052,8 @@ TEST_P(TDMVblank, VblankWaitSeqInterval) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestPrepareOutput() == true); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestPrepareOutput(), true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; @@ -1062,7 +1062,7 @@ TEST_P(TDMVblank, VblankWaitSeqInterval) if (!ut_tdm_vblank_is_avaiable(vblanks[v])) continue; - ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); interval = 1.0 / (double)fps; @@ -1070,14 +1070,14 @@ TEST_P(TDMVblank, VblankWaitSeqInterval) for (int t = 1; t < 10; t++) { unsigned int cur_seq = 0, temp = 0; - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); start = tdm_helper_get_time(); - ASSERT_TRUE(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + t, _ut_tdm_vblank_cb, &temp) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + t, _ut_tdm_vblank_cb, &temp), TDM_ERROR_NONE); while (temp == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); #if 0 @@ -1086,8 +1086,8 @@ printf("@@@ %s(%d) cur_seq(%d) t(%d) start(%.6f) end(%.6f) diff(%.6f) (%.6f~%.6f #endif /* "+ interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) > (interval * (t - 1))); - ASSERT_TRUE((end - start) < (interval * t + interval)); + ASSERT_GT((end - start), (interval * (t - 1))); + ASSERT_LT((end - start), (interval * t + interval)); } } } @@ -1098,36 +1098,36 @@ TEST_P(TDMVblank, VblankWaitNullObject) unsigned int cur_seq = 0; - ASSERT_TRUE(tdm_vblank_wait(NULL, 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_wait(NULL, 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankWaitNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestCreateVblanks(), true); - ASSERT_TRUE(tdm_vblank_wait(vblanks[0], 0, 0, 0, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankWaitDpmsOff) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestPrepareOutput() == true); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestPrepareOutput(), true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { tdm_error ret; tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); if (!ut_tdm_output_is_connected(output)) continue; - ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL) == TDM_ERROR_DPMS_OFF); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_DPMS_OFF); } } @@ -1135,24 +1135,24 @@ TEST_P(TDMVblank, VblankWaitBeforeDpmsOff) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestPrepareOutput() == true); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestPrepareOutput(), true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int temp = 0; tdm_error ret; tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); if (!ut_tdm_output_is_connected(output)) continue; - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &temp) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &temp), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); while (temp == 0) - ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } @@ -1160,13 +1160,13 @@ TEST_P(TDMVblank, VblankWaitSetEnableFakeDpmsOff) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestPrepareOutput() == true); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestPrepareOutput(), true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { tdm_error ret; tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); if (!ut_tdm_vblank_is_avaiable(vblanks[v])) continue; @@ -1174,11 +1174,11 @@ TEST_P(TDMVblank, VblankWaitSetEnableFakeDpmsOff) if (!ut_tdm_output_is_connected(output)) continue; - ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_set_enable_fake(vblanks[v], 1) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_NONE); } } @@ -1186,18 +1186,18 @@ TEST_P(TDMVblank, VblankWaitDisconnectedOutput) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestPrepareOutput() == true); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestPrepareOutput(), true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { tdm_error ret; tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); if (ut_tdm_output_is_connected(output)) continue; - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL) == TDM_ERROR_OUTPUT_DISCONNECTED); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_OUTPUT_DISCONNECTED); } } @@ -1205,8 +1205,8 @@ TEST_P(TDMVblank, VblankWaitSetOffset) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestPrepareOutput() == true); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestPrepareOutput(), true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; @@ -1215,9 +1215,9 @@ TEST_P(TDMVblank, VblankWaitSetOffset) if (!ut_tdm_vblank_is_avaiable(vblanks[v])) continue; - ASSERT_TRUE(tdm_vblank_set_offset(vblanks[v], 100) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 100), TDM_ERROR_NONE); - ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); interval = 1.0 / (double)fps; @@ -1225,14 +1225,14 @@ TEST_P(TDMVblank, VblankWaitSetOffset) unsigned int cur_seq = 0; start = tdm_helper_get_time(); - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) > (0.1)); - ASSERT_TRUE((end - start) < (interval + interval + 0.1)); + ASSERT_GT((end - start), (0.1)); + ASSERT_LT((end - start), (interval + interval + 0.1)); } } } @@ -1241,8 +1241,8 @@ TEST_P(TDMVblank, VblankWaitSetFps) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestPrepareOutput() == true); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestPrepareOutput(), true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; @@ -1251,26 +1251,26 @@ TEST_P(TDMVblank, VblankWaitSetFps) if (!ut_tdm_vblank_is_avaiable(vblanks[v])) continue; - ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); vrefresh_interval = 1.0 / (double)fps; fps /= 2; - ASSERT_TRUE(tdm_vblank_set_fps(vblanks[v], fps) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], fps), TDM_ERROR_NONE); interval = 1.0 / (double)fps; for (int t = 0; t < 3; t++) { unsigned int cur_seq = 0; start = tdm_helper_get_time(); - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) > (interval - vrefresh_interval)); - ASSERT_TRUE((end - start) < (interval + vrefresh_interval)); + ASSERT_GT((end - start), (interval - vrefresh_interval)); + ASSERT_LT((end - start), (interval + vrefresh_interval)); } } } @@ -1279,8 +1279,8 @@ TEST_P(TDMVblank, VblankWaitSetFixedFps) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestPrepareOutput() == true); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestPrepareOutput(), true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; @@ -1289,27 +1289,27 @@ TEST_P(TDMVblank, VblankWaitSetFixedFps) if (!ut_tdm_vblank_is_avaiable(vblanks[v])) continue; - ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); interval = 1.0 / (double)fps; - ASSERT_TRUE(tdm_vblank_set_fixed_fps(vblanks[v], fps) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], fps), TDM_ERROR_NONE); /* this fps will be ignored because it has fixed fps value */ fps /= 2; - ASSERT_TRUE(tdm_vblank_set_fps(vblanks[v], fps) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], fps), TDM_ERROR_NONE); for (int t = 0; t < 3; t++) { unsigned int cur_seq = 0; start = tdm_helper_get_time(); - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) < (interval + interval)); + ASSERT_LT((end - start), (interval + interval)); } } } @@ -1324,19 +1324,19 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps) unsigned int global_fps = 5; double start, end, interval; - ASSERT_TRUE(TestPrepareOutput() == true); - ASSERT_TRUE(TestCreateVblanks3() == true); - ASSERT_TRUE(vblank_count == 3); + ASSERT_EQ(TestPrepareOutput(), true); + ASSERT_EQ(TestCreateVblanks3(), true); + ASSERT_EQ(vblank_count, 3); if (!ut_tdm_vblank_is_avaiable(vblanks[0])) return; - ASSERT_TRUE(tdm_vblank_get_fps(vblanks[0], &fps) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE); ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE); vrefresh_interval = 1.0 / (double)fps; for (int v = 0; v < 3; v++) { - ASSERT_TRUE(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)), TDM_ERROR_NONE); interval = 1.0 / (double)(10 * (v + 1)); } @@ -1345,57 +1345,57 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps) for (int v = 0; v < 3; v++) { cur_seq[v] = 0; - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); } start = tdm_helper_get_time(); while (cur_seq[2] == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+- vrefresh_interval" consider the delay of socket communication between kernel and platform */ - ASSERT_TRUE((end - start) > (interval - vrefresh_interval)); - ASSERT_TRUE((end - start) < (interval + vrefresh_interval)); + ASSERT_GT((end - start), (interval - vrefresh_interval)); + ASSERT_LT((end - start), (interval + vrefresh_interval)); - ASSERT_TRUE(cur_seq[1] == 0); - ASSERT_TRUE(cur_seq[0] == 0); + ASSERT_EQ(cur_seq[1], 0); + ASSERT_EQ(cur_seq[0], 0); while (cur_seq[1] == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); - ASSERT_TRUE(cur_seq[0] == 0); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(cur_seq[0], 0); while (cur_seq[0] == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); /* disable test. global fps doesn't effect server's vblanks */ tdm_vblank_enable_global_fps(0, 0); for (int v = 0; v < 3; v++) { cur_seq[v] = 0; - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); } while (cur_seq[2] == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); - ASSERT_TRUE(cur_seq[1] == 0); - ASSERT_TRUE(cur_seq[0] == 0); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(cur_seq[1], 0); + ASSERT_EQ(cur_seq[0], 0); while (cur_seq[1] == 0) - ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE); - ASSERT_TRUE(cur_seq[0] == 0); + ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(cur_seq[0], 0); } TEST_P(TDMVblank, VblankWaitSetEnableFakeDisconnected) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_TRUE(TestPrepareOutput() == true); - ASSERT_TRUE(TestCreateVblanks() == true); + ASSERT_EQ(TestPrepareOutput(), true); + ASSERT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { tdm_error ret; tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret); - ASSERT_TRUE(ret == TDM_ERROR_NONE); + ASSERT_EQ(ret, TDM_ERROR_NONE); if (!ut_tdm_vblank_is_avaiable(vblanks[v])) continue; @@ -1403,9 +1403,9 @@ TEST_P(TDMVblank, VblankWaitSetEnableFakeDisconnected) if (ut_tdm_output_is_connected(output)) continue; - ASSERT_TRUE(tdm_vblank_set_enable_fake(vblanks[v], 1) == TDM_ERROR_DPMS_OFF); + ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_DPMS_OFF); - ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL) == TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_NONE); } } -- 2.7.4 From 24c294ef6276f751e96cfa4063bc853f161188e0 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Tue, 13 Mar 2018 16:30:00 +0900 Subject: [PATCH 16/16] package version up to 1.16.3 Change-Id: I40d9676982ebe15704123165193a99b2db2bb882 --- packaging/libtdm.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index e90f82c..829ac9a 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -2,7 +2,7 @@ %define UTEST_GCOV 0 Name: libtdm -Version: 1.16.2 +Version: 1.16.3 Release: 0 Summary: User Library of Tizen Display Manager Group: Development/Libraries -- 2.7.4