From 89a561cc4eeda090867bbd99e61062f88c8f9526 Mon Sep 17 00:00:00 2001 From: Junkyeong Kim Date: Wed, 7 Oct 2020 18:27:08 +0900 Subject: [PATCH 01/16] haltest: add skip condition to pp transform test Change-Id: I690d47be08425aaf9e70020c7848f1049ca66c42 Signed-off-by: Junkyeong Kim --- haltests/src/tc_tdm_backend_pp.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/haltests/src/tc_tdm_backend_pp.cpp b/haltests/src/tc_tdm_backend_pp.cpp index 47932ae..c59a381 100644 --- a/haltests/src/tc_tdm_backend_pp.cpp +++ b/haltests/src/tc_tdm_backend_pp.cpp @@ -733,6 +733,7 @@ retry: TEST_P(TDMBackendPP, PPConvertTransform) { TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(!(capabilities & TDM_PP_CAPABILITY_NO_TRANSFORM_ROTATION)); FindLayerUnderPrimary(); -- 2.7.4 From 85931bcd4f6443b638a1a159268403b7b7ace72a Mon Sep 17 00:00:00 2001 From: Junkyeong Kim Date: Wed, 21 Oct 2020 11:27:30 +0900 Subject: [PATCH 02/16] hwc: change use_vblank flag set position Change-Id: I4d7aeb5d879429a1380bccaffb7259f8feb2f3ec Signed-off-by: Junkyeong Kim --- src/tdm_hwc.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/tdm_hwc.c b/src/tdm_hwc.c index 47b6abb..a0109bf 100644 --- a/src/tdm_hwc.c +++ b/src/tdm_hwc.c @@ -268,7 +268,6 @@ _tdm_hwc_vblank(tdm_private_hwc *private_hwc, tdm_private_hwc_commit_handler *hw if (ret != TDM_ERROR_NONE) goto done; - hwc_commit_handler->use_vblank = 1; private_output->layer_waiting_vblank = 1; /* tdm_vblank APIs is for server. it should be called in unlock status*/ @@ -277,7 +276,6 @@ _tdm_hwc_vblank(tdm_private_hwc *private_hwc, tdm_private_hwc_commit_handler *hw _pthread_mutex_lock(&private_display->lock); if (ret != TDM_ERROR_NONE) { if (!TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->current_dpms_value)) { - hwc_commit_handler->use_vblank = 0; private_output->layer_waiting_vblank = 0; } } @@ -779,6 +777,8 @@ tdm_hwc_commit(tdm_hwc *hwc, int sync, tdm_hwc_commit_handler func, void *user_d hwc_commit_handler->func = func; hwc_commit_handler->user_data = user_data; hwc_commit_handler->owner_tid = syscall(SYS_gettid); + if (hwc_use_vblank) + hwc_commit_handler->use_vblank = 1; if (private_module == private_display->virtual_module) { private_voutput = private_output->private_voutput; -- 2.7.4 From 309ad21aba76781c724a00a8fd5a136664934b09 Mon Sep 17 00:00:00 2001 From: Junkyeong Kim Date: Fri, 23 Oct 2020 19:17:45 +0900 Subject: [PATCH 03/16] haltest: add line coverage excluding comments exclude virtual output related codes. (default off on mobile) exclude output commit reated codes. (vendor driven hwc is default) exclude hwc commit vblank related codes. (default off) Change-Id: I50c6f8625b63d192c464080f47a1eb791f984064 Signed-off-by: Junkyeong Kim --- src/tdm_display.c | 4 ++++ src/tdm_hwc.c | 4 ++++ src/tdm_output.c | 20 +++++++++++++++++--- src/tdm_server.c | 10 ++-------- 4 files changed, 27 insertions(+), 11 deletions(-) diff --git a/src/tdm_display.c b/src/tdm_display.c index e6c6df8..6603603 100644 --- a/src/tdm_display.c +++ b/src/tdm_display.c @@ -371,6 +371,7 @@ tdm_display_call_thread_cb_output_create(tdm_private_display *private_display, t return TDM_ERROR_NONE; } +/* LCOV_EXCL_START */ INTERN void tdm_display_thread_cb_output_create(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data) { @@ -466,6 +467,7 @@ tdm_display_remove_output_create_handler(tdm_display *dpy, _pthread_mutex_unlock(&private_display->lock); } +/* LCOV_EXCL_STOP */ EXTERN tdm_error tdm_display_get_capabilities(tdm_display *dpy, @@ -1016,6 +1018,7 @@ tdm_module_check_abi(tdm_private_module *private_module, int abimaj, int abimin) return 1; } +/* LCOV_EXCL_START */ INTERN tdm_voutput * tdm_display_voutput_create(tdm_display *dpy, const char *name, tdm_error *error) { @@ -1138,3 +1141,4 @@ tdm_display_voutput_create(tdm_display *dpy, const char *name, tdm_error *error) return private_voutput; } +/* LCOV_EXCL_STOP */ diff --git a/src/tdm_hwc.c b/src/tdm_hwc.c index a0109bf..ccf85ce 100644 --- a/src/tdm_hwc.c +++ b/src/tdm_hwc.c @@ -194,6 +194,7 @@ _tdm_hwc_cb_commit(tdm_hwc *hwc_backend, unsigned int sequence, TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } +/* LCOV_EXCL_START */ static void _tdm_hwc_got_wait_vblank(unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data) @@ -284,6 +285,7 @@ _tdm_hwc_vblank(tdm_private_hwc *private_hwc, tdm_private_hwc_commit_handler *hw done: return ret; } +/* LCOV_EXCL_STOP */ INTERN tdm_error tdm_hwc_init(tdm_private_display *private_display) @@ -793,6 +795,7 @@ tdm_hwc_commit(tdm_hwc *hwc, int sync, tdm_hwc_commit_handler func, void *user_d TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed); if (hwc_use_vblank) { + /* LCOV_EXCL_START */ ret = _tdm_hwc_vblank(private_hwc, hwc_commit_handler); if (ret == TDM_ERROR_NONE) { if (tdm_debug_module & TDM_DEBUG_COMMIT) @@ -800,6 +803,7 @@ tdm_hwc_commit(tdm_hwc *hwc, int sync, tdm_hwc_commit_handler func, void *user_d private_hwc->index, hwc_commit_handler, func, user_data); } else goto commit_failed; + /* LCOV_EXCL_STOP */ } else { if (tdm_debug_module & TDM_DEBUG_COMMIT) TDM_INFO("hwc(%d) backend commit: handle(%p) func(%p) user_data(%p)", diff --git a/src/tdm_output.c b/src/tdm_output.c index 9dc60a9..c7cf2c6 100644 --- a/src/tdm_output.c +++ b/src/tdm_output.c @@ -159,6 +159,7 @@ tdm_output_call_thread_cb_destroy(tdm_private_output *private_output) return TDM_ERROR_NONE; } +/* LCOV_EXCL_START */ INTERN void tdm_output_thread_cb_destroy(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data) { @@ -254,6 +255,7 @@ tdm_output_remove_destroy_handler(tdm_output *output, _pthread_mutex_unlock(&private_display->lock); } +/* LCOV_EXCL_STOP */ EXTERN tdm_module * tdm_output_get_backend_module(tdm_output *output, tdm_error *error) @@ -401,6 +403,7 @@ _tdm_output_call_thread_cb_dpms(tdm_private_output *private_output, tdm_output_d return TDM_ERROR_NONE; } +/* LCOV_EXCL_START */ INTERN void tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status, void *user_data) { @@ -438,6 +441,7 @@ tdm_output_cb_dpms(tdm_output *output_backend, tdm_output_dpms dpms, void *user_ ret = _tdm_output_call_thread_cb_dpms(private_output, dpms); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } +/* LCOV_EXCL_STOP */ EXTERN tdm_error tdm_output_add_change_handler(tdm_output *output, @@ -501,6 +505,7 @@ tdm_output_add_change_handler(tdm_output *output, return ret; } +/* LCOV_EXCL_START */ EXTERN tdm_error tdm_output_add_mode_change_request_handler(tdm_output *output, tdm_output_mode_change_request_handler func, @@ -579,6 +584,7 @@ tdm_output_remove_mode_change_request_handler(tdm_output *output, return TDM_ERROR_INVALID_PARAMETER; } +/* LCOV_EXCL_STOP */ EXTERN void tdm_output_remove_change_handler(tdm_output *output, @@ -1000,6 +1006,7 @@ _tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence, TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } +/* LCOV_EXCL_START */ static void _tdm_output_thread_cb_commit(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data) { @@ -1075,7 +1082,9 @@ _tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence, ret = tdm_thread_cb_call(private_output, &output_commit.base, 1); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } +/* LCOV_EXCL_STOP */ +/* LCOV_EXCL_START */ static void _tdm_voutput_thread_cb_commit(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data) { @@ -1156,6 +1165,7 @@ _tdm_voutput_cb_commit(tdm_voutput *voutput_backend, unsigned int sequence, ret = tdm_thread_cb_call(private_voutput, &voutput_commit.base, 1); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } +/* LCOV_EXCL_STOP */ /* add_front: To distinguish between the user vblank handlers and the layer * commit vblank handlers. The layer commit handlers will be called @@ -1334,6 +1344,7 @@ tdm_output_remove_vblank_handler_internal(tdm_output *output, tdm_output_vblank_ } } +/* LCOV_EXCL_START */ INTERN void tdm_output_remove_commit_handler_internal(tdm_output *output, tdm_output_commit_handler func, void *user_data) { @@ -1352,6 +1363,7 @@ tdm_output_remove_commit_handler_internal(tdm_output *output, tdm_output_commit_ } } } +/* LCOV_EXCL_STOP */ EXTERN tdm_error tdm_output_remove_vblank_handler(tdm_output *output, tdm_output_vblank_handler func, void *user_data) @@ -1367,6 +1379,7 @@ tdm_output_remove_vblank_handler(tdm_output *output, tdm_output_vblank_handler f return ret; } +/* LCOV_EXCL_START */ EXTERN tdm_error tdm_output_remove_commit_handler(tdm_output *output, tdm_output_commit_handler func, void *user_data) { @@ -1380,7 +1393,9 @@ tdm_output_remove_commit_handler(tdm_output *output, tdm_output_commit_handler f return ret; } +/* LCOV_EXCL_STOP */ +/* LCOV_EXCL_START */ INTERN void tdm_output_request_mode_set(tdm_output *output, unsigned int index) { @@ -1448,11 +1463,9 @@ tdm_output_set_voutput_commit(tdm_voutput *voutput) voutput_commit_handler = calloc(1, sizeof(tdm_private_voutput_commit_handler)); if (!voutput_commit_handler) { - /* LCOV_EXCL_START */ TDM_ERR("failed: alloc memory"); _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_OUT_OF_MEMORY; - /* LCOV_EXCL_STOP */ } ret = tdm_thread_cb_add(private_output->private_voutput, TDM_THREAD_CB_VOUTPUT_COMMIT, voutput_commit_handler, _tdm_voutput_thread_cb_commit, NULL); @@ -1528,6 +1541,7 @@ tdm_output_unset_voutput_commit(tdm_voutput *voutput) return TDM_ERROR_NONE; } +/* LCOV_EXCL_STOP */ /* LCOV_EXCL_START */ INTERN tdm_error @@ -2166,6 +2180,7 @@ tdm_output_choose_commit_per_vblank_mode(tdm_private_output *private_output, int return TDM_ERROR_NONE; } +/* LCOV_EXCL_START */ INTERN tdm_error tdm_voutput_destroy(tdm_voutput *voutput) { @@ -2319,7 +2334,6 @@ tdm_voutput_disconnect(tdm_voutput *voutput) return ret; } -/* LCOV_EXCL_START */ INTERN tdm_error tdm_voutput_set_commit_func(tdm_voutput *voutput, tdm_voutput_commit_handler func) { diff --git a/src/tdm_server.c b/src/tdm_server.c index a54e482..7e8fb20 100644 --- a/src/tdm_server.c +++ b/src/tdm_server.c @@ -821,6 +821,7 @@ _tdm_server_cb_create_output(struct wl_client *client, struct wl_resource *resou } } +/* LCOV_EXCL_START */ static void _tdm_voutput_cb_destroy(struct wl_client *client, struct wl_resource *resource) { wl_resource_destroy(resource); @@ -1173,25 +1174,17 @@ _tdm_output_get_voutput_buffer(tdm_server_voutput_info *voutput_info, tbm_surfac tbm_surface_internal_ref(buffer); voutput_buffer = calloc(1, sizeof *voutput_buffer); if (!voutput_buffer) { - /* LCOV_EXCL_START */ - TDM_ERR("fail calloc"); tbm_surface_internal_unref(buffer); return NULL; - - /* LCOV_EXCL_STOP */ } voutput_buffer->wl_buffer = _tdm_voutput_export_buffer(voutput_info, buffer); if (!voutput_buffer->wl_buffer) { - /* LCOV_EXCL_START */ - TDM_ERR("fail export buffer"); free(voutput_buffer); tbm_surface_internal_unref(buffer); return NULL; - - /* LCOV_EXCL_STOP */ } voutput_buffer->buffer = buffer; @@ -1371,6 +1364,7 @@ _tdm_server_cb_create_virtual_output(struct wl_client *client, struct wl_resourc wl_tdm_voutput_send_ack_message(voutput_resource, WL_TDM_VOUTPUT_MESSAGE_ADDED); } +/* LCOV_EXCL_STOP */ /* LCOV_EXCL_START */ static void -- 2.7.4 From 8877845d1e0c862778c6422e1799ae952f51abb5 Mon Sep 17 00:00:00 2001 From: Junkyeong Kim Date: Fri, 23 Oct 2020 19:21:42 +0900 Subject: [PATCH 04/16] haltest: add full path name for dump Change-Id: I738c31aed2de05dab3480aab947e78b8d59fe0b1 Signed-off-by: Junkyeong Kim --- haltests/src/tc_tdm_helper.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/haltests/src/tc_tdm_helper.cpp b/haltests/src/tc_tdm_helper.cpp index 6ac40da..fa94091 100644 --- a/haltests/src/tc_tdm_helper.cpp +++ b/haltests/src/tc_tdm_helper.cpp @@ -69,7 +69,7 @@ TEST_P(TDMHelper, HelperDumpBufferXR24) tdm_test_buffer_fill(buffer, PATTERN_SMPTE); char filename[256]; - snprintf(filename, sizeof filename, "%s.png", typeid(*this).name()); + snprintf(filename, sizeof filename, "/tmp/%s.png", typeid(*this).name()); tdm_helper_dump_buffer(buffer, (const char*)filename); tbm_surface_destroy(buffer); @@ -85,7 +85,7 @@ TEST_P(TDMHelper, HelperDumpBufferAR24) tdm_test_buffer_fill(buffer, PATTERN_SMPTE); char filename[256]; - snprintf(filename, sizeof filename, "%s.png", typeid(*this).name()); + snprintf(filename, sizeof filename, "/tmp/%s.png", typeid(*this).name()); tdm_helper_dump_buffer(buffer, (const char*)filename); tbm_surface_destroy(buffer); -- 2.7.4 From 8909a95085772f73dd6bbf6bfef6eb277843a6ca Mon Sep 17 00:00:00 2001 From: Changyeon Lee Date: Tue, 27 Oct 2020 14:53:53 +0900 Subject: [PATCH 05/16] tdm_hwc: add tdm_hwc_get_commit_interval interface Change-Id: Iacc89ddf45f5f7bea9b50f1292b7186c035a0a41 --- include/tdm.h | 9 +++++++++ include/tdm_backend.h | 8 ++++++++ include/tdm_types.h | 8 ++++++++ src/tdm_hwc.c | 27 +++++++++++++++++++++++++++ 4 files changed, 52 insertions(+) diff --git a/include/tdm.h b/include/tdm.h index 4a9d60d..92718f7 100644 --- a/include/tdm.h +++ b/include/tdm.h @@ -1094,6 +1094,15 @@ tdm_hwc_get_release_fences(tdm_hwc *hwc, uint32_t *num_elements, tdm_hwc_window **hwc_windows, int *fences); /** + * @brief Get the commit interval + * @param[in] hwc A hwc object + * @param[out] interval commit interval of backend + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + */ +tdm_error +tdm_hwc_get_commit_interval(tdm_hwc *hwc, tdm_hwc_commit_interval *interval); + +/** * @brief Set the property which has a given id on the hwc object. * @param[in] hwc A hwc object * @param[in] id The property id diff --git a/include/tdm_backend.h b/include/tdm_backend.h index f1f8084..5fe3f34 100644 --- a/include/tdm_backend.h +++ b/include/tdm_backend.h @@ -1016,6 +1016,14 @@ typedef struct _tdm_func_hwc { * @return #TDM_ERROR_NONE if success. Otherwise, error value. */ tdm_error (*hwc_get_property)(tdm_hwc *hwc, uint32_t id, tdm_value *value); + + /** + * @brief Get the commit interval + * @param[in] hwc A hwc object + * @param[out] interval commit interval of backend + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + */ + tdm_error (*hwc_get_commit_interval)(tdm_hwc *hwc, tdm_hwc_commit_interval *interval); } tdm_func_hwc; /** diff --git a/include/tdm_types.h b/include/tdm_types.h index d9ab984..4846002 100644 --- a/include/tdm_types.h +++ b/include/tdm_types.h @@ -222,6 +222,14 @@ typedef enum { TDM_HWC_WIN_CONSTRAINT_BUFFER_QUEUE = (1 << 0), } tdm_hwc_window_constraint; +typedef enum { + TDM_HWC_COMMIT_INTERVAL_NONE = 0, + /** If this interval is set by tdm backend, the compositor call commit per vblank + * even if the handler of commit isn't called. + */ + TDM_HWC_COMMIT_INTERVAL_VBLANK = 1, +} tdm_hwc_commit_interval; + /** * @brief The tdm display object */ diff --git a/src/tdm_hwc.c b/src/tdm_hwc.c index ccf85ce..76865e0 100644 --- a/src/tdm_hwc.c +++ b/src/tdm_hwc.c @@ -964,3 +964,30 @@ tdm_hwc_get_property(tdm_hwc *hwc, uint32_t id, tdm_value *value) return ret; } + +tdm_error +tdm_hwc_get_commit_interval(tdm_hwc *hwc, tdm_hwc_commit_interval *refresh) +{ + tdm_private_module *private_module; + tdm_func_hwc *func_hwc = NULL; + + HWC_FUNC_ENTRY(); + + _pthread_mutex_lock(&private_display->lock); + + private_module = private_hwc->private_module; + func_hwc = &private_module->func_hwc; + + /* LCOV_EXCL_START */ + if (!func_hwc->hwc_get_commit_interval) { + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_NOT_IMPLEMENTED; + } + + ret = func_hwc->hwc_get_commit_interval(private_hwc->hwc_backend, refresh); + /* LCOV_EXCL_STOP */ + + _pthread_mutex_unlock(&private_display->lock); + + return ret; +} -- 2.7.4 From 61de0893d9b7d85159e7a6e51dd12a57fb5f69d3 Mon Sep 17 00:00:00 2001 From: Junkyeong Kim Date: Fri, 23 Oct 2020 19:22:20 +0900 Subject: [PATCH 06/16] package version up to 2.12.0 Change-Id: I9cf74a439a8d04d1215319d704ed8ad28ff79f92 Signed-off-by: Junkyeong Kim --- packaging/libtdm.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index e6cb9f5..651fc00 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -2,7 +2,7 @@ %define HALTESTS_GCOV 0 Name: libtdm -Version: 2.11.3 +Version: 2.12.0 Release: 0 Summary: User Library of Tizen Display Manager Group: Development/Libraries -- 2.7.4 From 8eae4b43b4ab74cfd5d4f1cd34e86a9cbb4b66fb Mon Sep 17 00:00:00 2001 From: Junkyeong Kim Date: Mon, 4 Jan 2021 18:37:11 +0900 Subject: [PATCH 07/16] tdm_monitor: add dpms get method Change-Id: I2d4e33e68fda506f4ea9f9e644c32089ac7a2a1b Signed-off-by: Junkyeong Kim --- src/tdm_monitor_server.c | 49 ++++++++++++++++++++++++++++++++++-------------- 1 file changed, 35 insertions(+), 14 deletions(-) diff --git a/src/tdm_monitor_server.c b/src/tdm_monitor_server.c index a68ce21..0e8431a 100644 --- a/src/tdm_monitor_server.c +++ b/src/tdm_monitor_server.c @@ -67,33 +67,52 @@ static void _tdm_monitor_server_dpms(unsigned int pid, char *cwd, int argc, char *argv[], char *reply, int *len, tdm_display *dpy) { tdm_output *output; - int output_idx, dpms_value; + int output_idx, set, dpms_value = 0; + tdm_output_dpms dpms = TDM_OUTPUT_DPMS_ON; char *arg; char *end; tdm_error ret; - if (argc < 3) { + if (argc < 4) { _tdm_monitor_server_usage(argv[0], reply, len); return; } - arg = argv[2]; - output_idx = strtol(arg, &end, 10); - if (*end != ':') { - TDM_SNPRINTF(reply, len, "failed: no onoff value\n"); + set = strtol(argv[2], &end, 10); + if (!(set == 0 || set ==1)) { + _tdm_monitor_server_usage(argv[0], reply, len); return; } - arg = end + 1; - dpms_value = strtol(arg, &end, 10); + if (set == 1) { + arg = argv[3]; + output_idx = strtol(arg, &end, 10); + if (*end != ':') { + TDM_SNPRINTF(reply, len, "failed: no onoff value\n"); + return; + } - output = tdm_display_get_output(dpy, output_idx, &ret); - TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE && output != NULL); + arg = end + 1; + dpms_value = strtol(arg, &end, 10); - ret = tdm_output_set_dpms(output, dpms_value); - TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE); + output = tdm_display_get_output(dpy, output_idx, &ret); + TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE && output != NULL); + + ret = tdm_output_set_dpms(output, dpms_value); + TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE); + + TDM_SNPRINTF(reply, len, "done: DPMS set %s\n", tdm_dpms_str(dpms_value)); + } else { + output_idx = strtol(argv[3], &end, 10); + + output = tdm_display_get_output(dpy, output_idx, &ret); + TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE && output != NULL); - TDM_SNPRINTF(reply, len, "done: DPMS %s\n", tdm_dpms_str(dpms_value)); + ret = tdm_output_get_dpms(output, &dpms); + TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE); + + TDM_SNPRINTF(reply, len, "done: DPMS get %s\n", tdm_dpms_str(dpms)); + } } static void @@ -496,7 +515,9 @@ static struct { }, { "dpms", _tdm_monitor_server_dpms, - "set output dpms", ":", "0:3 or 0:0" + "set/get output dpms", + " :", + "0 0 (get) or 1 0:3 (set off) or 1 0:0 (set on)" }, { "ttrace", _tdm_monitor_server_ttrace, -- 2.7.4 From 1e04d3e11f5c7c1e1f99f1371497114322ff59f1 Mon Sep 17 00:00:00 2001 From: Junkyeong Kim Date: Wed, 6 Jan 2021 11:45:49 +0900 Subject: [PATCH 08/16] tdm_hwc_window: add display_buffer and composition_type for debugging Change-Id: I7f502e80da599c8ce9861eef72f7099169422d02 Signed-off-by: Junkyeong Kim --- src/tdm_hwc_window.c | 4 ++++ src/tdm_private_types.h | 3 +++ 2 files changed, 7 insertions(+) diff --git a/src/tdm_hwc_window.c b/src/tdm_hwc_window.c index 2e861d8..953144e 100644 --- a/src/tdm_hwc_window.c +++ b/src/tdm_hwc_window.c @@ -275,6 +275,8 @@ tdm_hwc_window_set_composition_type(tdm_hwc_window *hwc_window, } ret = func_hwc_window->hwc_window_set_composition_type(private_hwc_window->hwc_window_backend, composition_type); + if (ret == TDM_ERROR_NONE) + private_hwc_window->composition_type = composition_type; _pthread_mutex_unlock(&private_display->lock); @@ -380,6 +382,8 @@ tdm_hwc_window_set_buffer(tdm_hwc_window *hwc_window, tbm_surface_h buffer) } ret = func_hwc_window->hwc_window_set_buffer(private_hwc_window->hwc_window_backend, buffer); + if (ret == TDM_ERROR_NONE) + private_hwc_window->display_buffer = buffer; _pthread_mutex_unlock(&private_display->lock); diff --git a/src/tdm_private_types.h b/src/tdm_private_types.h index 289033f..b68e229 100644 --- a/src/tdm_private_types.h +++ b/src/tdm_private_types.h @@ -344,6 +344,9 @@ struct _tdm_private_hwc_window { tdm_private_hwc *private_hwc; tdm_hwc_window *hwc_window_backend; + + tbm_surface_h display_buffer; + tdm_hwc_window_composition composition_type; }; struct _tdm_private_pp { -- 2.7.4 From 0f2ec02b268005e27f3c2560f0042b7ef41e0aeb Mon Sep 17 00:00:00 2001 From: Junkyeong Kim Date: Wed, 6 Jan 2021 11:48:19 +0900 Subject: [PATCH 09/16] tdm_display: support dump current option for hwc_window Change-Id: Ic96dffc9815291fbf4905a37416fa12a3e58b6a2 Signed-off-by: Junkyeong Kim --- src/tdm_display.c | 62 +++++++++++++++++++++++++++++++++++++++---------------- 1 file changed, 44 insertions(+), 18 deletions(-) diff --git a/src/tdm_display.c b/src/tdm_display.c index 6603603..cf974ec 100644 --- a/src/tdm_display.c +++ b/src/tdm_display.c @@ -104,6 +104,49 @@ tdm_display_enable_debug_module(const char*modules) return TDM_ERROR_NONE; } +void +_tdm_display_enable_dump_current(tdm_private_display *private_display, char *path) +{ + tdm_private_module *b = NULL; + tdm_private_output *o = NULL; + + LIST_FOR_EACH_ENTRY(b, &private_display->module_list, link) { + LIST_FOR_EACH_ENTRY(o, &b->output_list, link) { + if (o->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) { + tdm_private_hwc *private_hwc = NULL; + tdm_private_hwc_window *w = NULL; + int index = 0; + private_hwc = o->private_hwc; + if (private_hwc->display_target_buffer) { + char str[TDM_PATH_LEN]; + snprintf(str, TDM_PATH_LEN, "window_%d_target", private_hwc->index); + tdm_helper_dump_buffer_str(private_hwc->display_target_buffer, path, str); + } + LIST_FOR_EACH_ENTRY(w, &private_hwc->hwc_window_list, link) { + char str[TDM_PATH_LEN]; + if (!w->display_buffer) + continue; + if (w->composition_type != TDM_HWC_WIN_COMPOSITION_DEVICE) + continue; + snprintf(str, TDM_PATH_LEN, "window_%d_%d", private_hwc->index, index++); + tdm_helper_dump_buffer_str(w->display_buffer, path, str); + } + } else { + tdm_private_layer *l = NULL; + LIST_FOR_EACH_ENTRY(l, &o->layer_list, link) { + char str[TDM_PATH_LEN]; + if (l->usable || l->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO) + continue; + if (!l->showing_buffer) + continue; + snprintf(str, TDM_PATH_LEN, "layer_%d_%d", o->index, l->index); + tdm_helper_dump_buffer_str(l->showing_buffer->buffer, path, str); + } + } + } + } +} + INTERN tdm_error tdm_display_enable_dump(tdm_private_display *private_display, const char *dump_str, char *reply, int *len) { @@ -139,29 +182,12 @@ tdm_display_enable_dump(tdm_private_display *private_display, const char *dump_s TDM_GOTO_IF_FAIL(path != NULL, done); if (!strncmp(arg, "current", 7)) { - tdm_private_module *b = NULL; - tdm_private_output *o = NULL; - if (!private_display) { TDM_WRN("no private_display"); goto done; } - LIST_FOR_EACH_ENTRY(b, &private_display->module_list, link) { - LIST_FOR_EACH_ENTRY(o, &b->output_list, link) { - tdm_private_layer *l = NULL; - LIST_FOR_EACH_ENTRY(l, &o->layer_list, link) { - char str[TDM_PATH_LEN]; - if (l->usable || l->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO) - continue; - if (!l->showing_buffer) - continue; - snprintf(str, TDM_PATH_LEN, "layer_%d_%d", o->index, l->index); - tdm_helper_dump_buffer_str(l->showing_buffer->buffer, path, str); - } - } - } - + _tdm_display_enable_dump_current(private_display, path); TDM_SNPRINTF(reply, len, "path: %s\n", path); goto done; } -- 2.7.4 From fbe7ee36600b16cb0f9b4dd361b0c8afd412f44a Mon Sep 17 00:00:00 2001 From: Junkyeong Kim Date: Wed, 6 Jan 2021 11:49:45 +0900 Subject: [PATCH 10/16] tdm_monitor: add dump usage about window Change-Id: Ibb2d842dd600da4a7439ddda938d768834dbb44b Signed-off-by: Junkyeong Kim --- src/tdm_monitor_server.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/tdm_monitor_server.c b/src/tdm_monitor_server.c index 0e8431a..4402f3d 100644 --- a/src/tdm_monitor_server.c +++ b/src/tdm_monitor_server.c @@ -575,10 +575,10 @@ static struct { }, { "dump", _tdm_monitor_server_dump, - "dump buffers (type: none, layer, pp, capture, current)\n" - "\t\t layer, pp, capture - start to dump buffers of layer, pp, capture\n" - "\t\t none - stop to dump buffers\n" - "\t\t current - dump the current buffer of all layers", + "dump buffers (type: none, window, layer, pp, capture, current)\n" + "\t\t window, layer, pp, capture - start to dump buffers of window, layer, pp, capture\n" + "\t\t none - stop to dump buffers\n" + "\t\t current - dump the current buffer of all layers", "[,[,...]][@]", NULL }, -- 2.7.4 From ccb7105f017ebeb98560797b994f962e0d60beec Mon Sep 17 00:00:00 2001 From: Junkyeong Kim Date: Tue, 2 Feb 2021 20:50:17 +0900 Subject: [PATCH 11/16] adapt hal-api-tdm libtdm uses hal-api-tdm from Tizen 6.5. Therefore, libtdm links libhal-api-tdm library and libtdm work with hal-api-tdm when the hal-backend-tdm backend library at /hal/lib directory. If not, libtdm works with the legacy tdm backend so file at /usr/lib/tdm directory. Change-Id: I76aebd60306d87705669c61af1033259ed3a1a67 Signed-off-by: Junkyeong Kim --- configure.ac | 2 +- packaging/libtdm.spec | 1 + src/tdm.c | 177 +++++++++++++++++--- src/tdm_capture.c | 129 ++++++++++----- src/tdm_display.c | 81 ++++++---- src/tdm_event_loop.c | 59 ++++--- src/tdm_helper.c | 14 +- src/tdm_hwc.c | 396 ++++++++++++++++++++++++++++----------------- src/tdm_hwc_window.c | 243 +++++++++++++++++----------- src/tdm_output.c | 422 +++++++++++++++++++++++++++++++++--------------- src/tdm_pp.c | 131 ++++++++++----- src/tdm_private.h | 4 + src/tdm_private_types.h | 7 + 13 files changed, 1144 insertions(+), 522 deletions(-) diff --git a/configure.ac b/configure.ac index 51ceb3c..c0bf70a 100644 --- a/configure.ac +++ b/configure.ac @@ -44,7 +44,7 @@ fi PKG_CHECK_MODULES(WAYLAND_SCANNER, wayland-scanner >= 1.7.0) -PKG_CHECK_MODULES(TDM, dlog libtbm libpng pixman-1 wayland-server iniparser) +PKG_CHECK_MODULES(TDM, dlog libtbm libpng pixman-1 wayland-server iniparser hal-api-tdm) PKG_CHECK_MODULES(TDM_CLIENT, dlog libtbm wayland-client) PKG_CHECK_MODULES(TTRACE, diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index 651fc00..7cbf49b 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -16,6 +16,7 @@ BuildRequires: pkgconfig(wayland-server) BuildRequires: pkgconfig(wayland-client) BuildRequires: pkgconfig(iniparser) BuildRequires: pkgconfig(pixman-1) +BuildRequires: pkgconfig(hal-api-tdm) BuildRequires: gtest-devel %description diff --git a/src/tdm.c b/src/tdm.c index 6742bd2..77a7f9d 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -465,17 +465,27 @@ _tdm_display_update_caps_output(tdm_private_module *private_module, int pipe, tdm_func_output *func_output = &private_module->func_output; char temp[TDM_NAME_LEN]; tdm_error ret; + hal_tdm_error hret; double stamp; int n; stamp = tdm_helper_get_time(); - ret = func_output->output_get_capability(output_backend, caps); - TDM_DBG("backend(%s) backend output_get_capability() time: %.3f ms", - private_module->module_data->name, (tdm_helper_get_time() - stamp) * 1000.0); - - if (ret != TDM_ERROR_NONE) { - TDM_ERR("backend(%s) output_get_capability() failed", private_module->module_data->name); - return TDM_ERROR_BAD_MODULE; + if (private_module->use_hal_tdm) { + hret = hal_tdm_output_get_capability(output_backend, (hal_tdm_caps_output *)caps); + TDM_DBG("backend(HAL-TDM) backend output_get_capability() time: %.3f ms", + (tdm_helper_get_time() - stamp) * 1000.0); + if (hret != HAL_TDM_ERROR_NONE) { + TDM_ERR("backend(HAL-TDM) output_get_capability() failed"); + return TDM_ERROR_BAD_MODULE; + } + } else { + ret = func_output->output_get_capability(output_backend, caps); + TDM_DBG("backend(%s) backend output_get_capability() time: %.3f ms", + private_module->module_data->name, (tdm_helper_get_time() - stamp) * 1000.0); + if (ret != TDM_ERROR_NONE) { + TDM_ERR("backend(%s) output_get_capability() failed", private_module->module_data->name); + return TDM_ERROR_BAD_MODULE; + } } /* FIXME: Use model for tdm client to distinguish amoung outputs */ @@ -563,11 +573,18 @@ tdm_display_update_output(tdm_private_module *private_module, tdm_output *output LIST_INITHEAD(&private_output->change_handler_list); LIST_INITHEAD(&private_output->mode_change_request_handler_list); - if (func_output->output_set_status_handler) { - func_output->output_set_status_handler(private_output->output_backend, - tdm_output_cb_status, - private_output); - private_output->regist_change_cb = 1; + if (private_module->use_hal_tdm) { + hal_tdm_error hret; + hret = hal_tdm_output_set_status_handler(private_output->output_backend, tdm_output_cb_status_hal_tdm, private_output); + if (hret == HAL_TDM_ERROR_NONE) + private_output->regist_change_cb = 1; + } else { + if (func_output->output_set_status_handler) { + func_output->output_set_status_handler(private_output->output_backend, + tdm_output_cb_status, + private_output); + private_output->regist_change_cb = 1; + } } output_created = 1; @@ -581,8 +598,11 @@ tdm_display_update_output(tdm_private_module *private_module, tdm_output *output private_output->current_mode = NULL; /* get the tdm_hwc object */ - if (private_output->caps.capabilities&TDM_OUTPUT_CAPABILITY_HWC) { - hwc = func_output->output_get_hwc(output_backend, &ret); + if (private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) { + if (private_module->use_hal_tdm) + hwc = (tdm_hwc *)hal_tdm_output_get_hwc(output_backend, (hal_tdm_error *)&ret); + else + hwc = func_output->output_get_hwc(output_backend, &ret); TDM_RETURN_VAL_IF_FAIL(hwc != NULL, ret); private_hwc = calloc(1, sizeof(tdm_private_hwc)); @@ -614,7 +634,11 @@ tdm_display_update_output(tdm_private_module *private_module, tdm_output *output } /* do not use the layer object when the tdm_output has the hwc capability */ - if ((private_output->caps.capabilities&TDM_OUTPUT_CAPABILITY_HWC) == 0) { + if ((private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) == 0) { + if (private_module->use_hal_tdm) { + TDM_ERR("hal-tdm not support layer"); + return TDM_ERROR_NOT_IMPLEMENTED; + } layers = func_output->output_get_layers(output_backend, &layer_count, &ret); if (ret != TDM_ERROR_NONE) { free(layers); @@ -672,7 +696,10 @@ _tdm_display_get_ordered_outputs(tdm_private_module *private_module, int *count) return private_module->outputs; } - outputs = func_display->display_get_outputs(private_module->bdata, &output_count, &ret); + if (private_module->use_hal_tdm) + outputs = (tdm_output **)hal_tdm_display_get_outputs(private_module->htdm_backend, &output_count, (hal_tdm_error *)&ret); + else + outputs = func_display->display_get_outputs(private_module->bdata, &output_count, &ret); if (ret != TDM_ERROR_NONE) goto no_output; @@ -691,7 +718,10 @@ _tdm_display_get_ordered_outputs(tdm_private_module *private_module, int *count) tdm_caps_output caps; memset(&caps, 0, sizeof(tdm_caps_output)); - ret = func_output->output_get_capability(outputs[i], &caps); + if (private_module->use_hal_tdm) + ret = (tdm_error)hal_tdm_output_get_capability(outputs[i], (hal_tdm_caps_output *)&caps); + else + ret = func_output->output_get_capability(outputs[i], &caps); if (ret != TDM_ERROR_NONE) { TDM_ERR("output_get_capability() failed"); goto no_output; @@ -777,14 +807,14 @@ _tdm_display_setup(tdm_private_display *private_display) int virtual = 0; int virtual_hwc_target_buffer_bo_default = 0; - if (private_display->pp_module) { + if (private_display->pp_module && !private_display->pp_module->use_hal_tdm) { ret = _tdm_display_update_caps_pp(private_display->pp_module, &private_display->pp_module->caps_pp); if (ret != TDM_ERROR_NONE) goto failed_update; } - if (private_display->capture_module) { + if (private_display->capture_module && !private_display->pp_module->use_hal_tdm) { ret = _tdm_display_update_caps_capture(private_display->capture_module, &private_display->capture_module->caps_capture); if (ret != TDM_ERROR_NONE) @@ -875,6 +905,103 @@ static pthread_mutex_t gLock = PTHREAD_MUTEX_INITIALIZER; /* LCOV_EXCL_START */ static tdm_error +_tdm_display_load_hal_backend(tdm_private_display *private_display) +{ + hal_tdm_backend *hal_tdm = NULL; + hal_tdm_display *hal_tdm_dpy = NULL; + tdm_private_module *private_module = NULL; + hal_tdm_event_source **event_sources = NULL; + hal_tdm_caps_display caps; + hal_tdm_caps_pp pp_caps; + hal_tdm_caps_capture capture_caps; + hal_tdm_error hret; + tdm_error error; + int num = 0; + + hal_tdm = hal_tdm_get_backend(&hret); + if (hal_tdm == NULL || hret != HAL_TDM_ERROR_NONE) { + TDM_INIT_INFO("failed hal_tdm_get_backend"); + return TDM_ERROR_NO_MODULE; + } + + private_module = calloc(1, sizeof *private_module); + if (private_module == NULL) { + TDM_ERR("failed: alloc"); + hal_tdm_put_backend(hal_tdm); + return TDM_ERROR_OUT_OF_MEMORY; + } + + hal_tdm_dpy = hal_tdm_backend_get_display(hal_tdm, &hret); + if (hal_tdm_dpy == NULL || hret != HAL_TDM_ERROR_NONE) { + TDM_ERR("failed hal_tdm_backend_get_display"); + goto fail; + } + + if (hal_tdm_display_get_capability(hal_tdm_dpy, &caps) != HAL_TDM_ERROR_NONE) { + TDM_ERR("failed hal_tdm_display_get_capability"); + goto fail; + } + + private_module->use_hal_tdm = 1; + private_module->htdm_backend = hal_tdm; + private_module->htdm_dpy = hal_tdm_dpy; + private_module->private_display = private_display; + private_display->current_module = private_module; + + if (hal_tdm_display_get_pp_capability(hal_tdm_dpy, &pp_caps) == HAL_TDM_ERROR_NONE) { + private_display->pp_module = private_module; + private_module->caps_pp.capabilities = (tdm_pp_capability)pp_caps.capabilities; + private_module->caps_pp.format_count = pp_caps.format_count; + private_module->caps_pp.formats = pp_caps.formats; + private_module->caps_pp.min_w = pp_caps.min_w; + private_module->caps_pp.min_h = pp_caps.min_h; + private_module->caps_pp.max_w = pp_caps.max_w; + private_module->caps_pp.max_h = pp_caps.max_h; + private_module->caps_pp.preferred_align = pp_caps.preferred_align; + private_module->caps_pp.preferred_align_vertical = pp_caps.preferred_align_vertical; + private_module->caps_pp.max_attach_count = pp_caps.max_attach_count; + } + if (hal_tdm_display_get_capture_capability(hal_tdm_dpy, &capture_caps) == HAL_TDM_ERROR_NONE) { + private_display->capture_module = private_module; + private_module->caps_capture.capabilities = (tdm_capture_capability)capture_caps.capabilities; + private_module->caps_capture.format_count = capture_caps.format_count; + private_module->caps_capture.formats = capture_caps.formats; + private_module->caps_capture.min_w = capture_caps.min_w; + private_module->caps_capture.min_h = capture_caps.min_h; + private_module->caps_capture.max_w = capture_caps.max_w; + private_module->caps_capture.max_h = capture_caps.max_h; + private_module->caps_capture.preferred_align = capture_caps.preferred_align; + private_module->caps_capture.max_attach_count = capture_caps.max_attach_count; + } + + LIST_INITHEAD(&private_module->output_list); + LIST_INITHEAD(&private_module->voutput_list); + LIST_INITHEAD(&private_module->pp_list); + LIST_INITHEAD(&private_module->capture_list); + + LIST_ADDTAIL(&private_module->link, &private_display->module_list); + + event_sources = hal_tdm_backend_get_event_sources(hal_tdm, &num, &hret); + if (num != 0 && hret == HAL_TDM_ERROR_NONE) { + for (int i = 0; i < num; i++) { + hal_tdm_event_source *event_source = event_sources[i]; + private_module->htdm_event_source = tdm_event_loop_add_fd_handler(private_display, event_source->event_fd, + TDM_EVENT_LOOP_READABLE, (tdm_event_loop_fd_handler)event_source->func, event_source->user_data, &error); + break; + } + } + + TDM_INIT_INFO("use hal tdm"); + + return TDM_ERROR_NONE; + +fail: + hal_tdm_put_backend(hal_tdm); + free(private_module); + return TDM_ERROR_NO_MODULE; +} + +static tdm_error _tdm_display_check_module(tdm_backend_module *module) { int tdm_backend_major, tdm_backend_minor; @@ -1109,6 +1236,11 @@ _tdm_display_load_modules(tdm_private_display *private_display) LIST_INITHEAD(&private_display->module_list); + if (_tdm_display_load_hal_backend(private_display) == TDM_ERROR_NONE) { + TDM_INIT_INFO("use hal tdm"); + return ret; + } + module_names = tdm_config_get_string(TDM_CONFIG_KEY_GENERAL_BACKENDS, TDM_DEFAULT_MODULE); snprintf(temp, TDM_PATH_LEN, "%s", module_names); @@ -1134,6 +1266,13 @@ _tdm_display_unload_modules(tdm_private_display *private_display) LIST_FOR_EACH_ENTRY_SAFE(private_module, bb, &private_display->module_list, link) { LIST_DEL(&private_module->link); + if (private_module->use_hal_tdm) { + if (private_module->htdm_event_source) + tdm_event_loop_source_remove(private_module->htdm_event_source); + hal_tdm_put_backend(private_module->htdm_backend); + free(private_module); + continue; + } if (private_module->module_data) private_module->module_data->deinit(private_module->bdata); diff --git a/src/tdm_capture.c b/src/tdm_capture.c index 1fd5bb4..5054136 100644 --- a/src/tdm_capture.c +++ b/src/tdm_capture.c @@ -174,6 +174,27 @@ _tdm_capture_cb_done(tdm_capture *capture_module, tbm_surface_h buffer, void *us TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } +static void +_tdm_capture_cb_done_hal_tdm(hal_tdm_capture *capture_module, tbm_surface_h buffer, void *user_data) +{ + tdm_private_capture *private_capture = user_data; + tdm_thread_cb_capture_done capture_done; + tdm_error ret; + + TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED()); + + memset(&capture_done, 0, sizeof capture_done); + capture_done.base.type = TDM_THREAD_CB_CAPTURE_DONE; + capture_done.base.length = sizeof capture_done; + capture_done.base.object_stamp = private_capture->stamp; + capture_done.base.data = NULL; + capture_done.base.sync = 0; + capture_done.buffer = buffer; + + ret = tdm_thread_cb_call(private_capture, &capture_done.base, 1); + TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); +} + static void * _tdm_capture_find_object(tdm_private_display *private_display, double stamp) { @@ -232,12 +253,13 @@ tdm_capture_create_output_internal(tdm_private_output *private_output, /* LCOV_EXCL_STOP */ } - capture_module = func_output->output_create_capture( - private_output->output_backend, &ret); + if (private_module->use_hal_tdm) + capture_module = (tdm_capture *)hal_tdm_output_create_capture(private_output->output_backend, (hal_tdm_error *)&ret); + else + capture_module = func_output->output_create_capture(private_output->output_backend, &ret); if (ret != TDM_ERROR_NONE) { /* LCOV_EXCL_START */ - if (error) - *error = ret; + if (error) *error = ret; return NULL; /* LCOV_EXCL_STOP */ } @@ -246,32 +268,29 @@ tdm_capture_create_output_internal(tdm_private_output *private_output, if (!private_capture) { /* LCOV_EXCL_START */ TDM_ERR("failed: alloc memory"); - func_capture->capture_destroy(capture_module); - if (error) - *error = TDM_ERROR_OUT_OF_MEMORY; - return NULL; + if (error) *error = TDM_ERROR_OUT_OF_MEMORY; + goto alloc_fail; /* LCOV_EXCL_STOP */ } ret = tdm_thread_cb_add(private_capture, TDM_THREAD_CB_CAPTURE_DONE, NULL, _tdm_capture_thread_cb_done, NULL); if (ret != TDM_ERROR_NONE) { + /* LCOV_EXCL_START */ TDM_ERR("capture tdm_thread_cb_add failed"); - func_capture->capture_destroy(capture_module); - free(private_capture); - if (error) - *error = ret; - return NULL; + if (error) *error = ret; + goto thread_fail; + /* LCOV_EXCL_STOP */ } - ret = func_capture->capture_set_done_handler(capture_module, _tdm_capture_cb_done, private_capture); + if (private_module->use_hal_tdm) + ret = (hal_tdm_error)hal_tdm_capture_set_done_handler((hal_tdm_capture *)capture_module, _tdm_capture_cb_done_hal_tdm, private_capture); + else + ret = func_capture->capture_set_done_handler(capture_module, _tdm_capture_cb_done, private_capture); if (ret != TDM_ERROR_NONE) { /* LCOV_EXCL_START */ TDM_ERR("capture(%p) set capture_done_handler failed", private_capture); - func_capture->capture_destroy(capture_module); - free(private_capture); - if (error) - *error = ret; - return NULL; + if (error) *error = ret; + goto thread_fail; /* LCOV_EXCL_STOP */ } @@ -300,6 +319,16 @@ tdm_capture_create_output_internal(tdm_private_output *private_output, *error = TDM_ERROR_NONE; return private_capture; + +thread_fail: + free(private_capture); +alloc_fail: + if (private_module->use_hal_tdm) + hal_tdm_capture_destroy((hal_tdm_capture *)capture_module); + else + func_capture->capture_destroy(capture_module); + + return NULL; } /* LCOV_EXCL_START */ @@ -397,7 +426,10 @@ tdm_capture_destroy_internal(tdm_private_capture *private_capture) private_module = private_capture->private_module; func_capture = &private_module->func_capture; - func_capture->capture_destroy(private_capture->capture_module); + if (private_module->use_hal_tdm) + hal_tdm_capture_destroy((hal_tdm_capture *)private_capture->capture_module); + else + func_capture->capture_destroy(private_capture->capture_module); if (!LIST_IS_EMPTY(&private_capture->pending_buffer_list)) { TDM_WRN("capture(%p) not finished:", private_capture); @@ -481,12 +513,14 @@ tdm_capture_set_info(tdm_capture *capture, tdm_info_capture *info) _pthread_mutex_lock(&private_display->lock); - if (!func_capture->capture_set_info) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_DBG("failed: not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ + if (!private_module->use_hal_tdm) { + if (!func_capture->capture_set_info) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } } if (info->type == TDM_CAPTURE_TYPE_STREAM && info->frequency == 0) { @@ -502,7 +536,10 @@ tdm_capture_set_info(tdm_capture *capture, tdm_info_capture *info) FOURCC_STR(info->dst_config.format), info->transform, info->type, info->frequency, info->flags); - ret = func_capture->capture_set_info(private_capture->capture_module, info); + if (private_module->use_hal_tdm) + ret = (tdm_error)hal_tdm_capture_set_info((hal_tdm_capture *)private_capture->capture_module, (hal_tdm_info_capture *)info); + else + ret = func_capture->capture_set_info(private_capture->capture_module, info); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); private_capture->info = *info; @@ -547,12 +584,14 @@ tdm_capture_attach(tdm_capture *capture, tbm_surface_h buffer) _pthread_mutex_lock(&private_display->lock); - if (!func_capture->capture_attach) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_DBG("failed: not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ + if (!private_module->use_hal_tdm) { + if (!func_capture->capture_attach) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } } if (tdm_module_check_abi(private_module, 1, 2) && @@ -578,7 +617,10 @@ tdm_capture_attach(tdm_capture *capture, tbm_surface_h buffer) /* LCOV_EXCL_STOP */ } - ret = func_capture->capture_attach(private_capture->capture_module, buffer); + if (private_module->use_hal_tdm) + ret = (tdm_error)hal_tdm_capture_attach((hal_tdm_capture *)private_capture->capture_module, buffer); + else + ret = func_capture->capture_attach(private_capture->capture_module, buffer); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); if (ret != TDM_ERROR_NONE) { @@ -630,12 +672,14 @@ tdm_capture_commit(tdm_capture *capture) return TDM_ERROR_BAD_REQUEST; } - if (!func_capture->capture_commit) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_DBG("failed: not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ + if (!private_module->use_hal_tdm) { + if (!func_capture->capture_commit) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } } LIST_INITHEAD(&commit_buffer_list); @@ -652,7 +696,10 @@ tdm_capture_commit(tdm_capture *capture) _tdm_capture_print_list(&private_capture->buffer_list); } - ret = func_capture->capture_commit(private_capture->capture_module); + if (private_module->use_hal_tdm) + ret = (tdm_error)hal_tdm_capture_commit((hal_tdm_capture *)private_capture->capture_module); + else + ret = func_capture->capture_commit(private_capture->capture_module); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); LIST_FOR_EACH_ENTRY_SAFE(b, bb, &commit_buffer_list, commit_link) { diff --git a/src/tdm_display.c b/src/tdm_display.c index cf974ec..49c8451 100644 --- a/src/tdm_display.c +++ b/src/tdm_display.c @@ -1076,59 +1076,55 @@ tdm_display_voutput_create(tdm_display *dpy, const char *name, tdm_error *error) return NULL; } - func_display = &private_module->func_display; - func_voutput = &private_module->func_voutput; current_module = private_display->current_module; private_display->current_module = private_module; - voutput_backend = func_display->display_voutput_create(private_module->bdata, name, &ret); - + if (private_module->use_hal_tdm) { + voutput_backend = (tdm_voutput *)hal_tdm_display_voutput_create(private_module->htdm_backend, name, (hal_tdm_error *)&ret); + } else { + func_display = &private_module->func_display; + func_voutput = &private_module->func_voutput; + voutput_backend = func_display->display_voutput_create(private_module->bdata, name, &ret); + } if (voutput_backend == NULL || ret != TDM_ERROR_NONE) { TDM_ERR("display_voutput_create fail"); - free(private_voutput); if (error) *error = ret; - private_display->current_module = current_module; - _pthread_mutex_unlock(&private_display->lock); - return NULL; + goto voutput_create_fail; } private_voutput->voutput_backend = voutput_backend; private_voutput->private_display = private_display; private_voutput->private_module = private_module; LIST_INITHEAD(&private_voutput->voutput_commit_handler_list); - output_backend = func_voutput->voutput_get_output(voutput_backend, &ret); + if (private_module->use_hal_tdm) + output_backend = (tdm_output *)hal_tdm_voutput_get_output((hal_tdm_voutput *)voutput_backend, (hal_tdm_error *)&ret); + else + output_backend = func_voutput->voutput_get_output(voutput_backend, &ret); if (output_backend == NULL || ret != TDM_ERROR_NONE) { TDM_ERR("voutput_get_output fail"); - free(private_voutput); if (error) *error = ret; - if (func_voutput->voutput_destroy) - func_voutput->voutput_destroy(voutput_backend); - else - TDM_ERR("no destroy function"); - private_display->current_module = current_module; - _pthread_mutex_unlock(&private_display->lock); - return NULL; + goto output_get_fail; } - if (func_voutput->voutput_set_target_buffer_queue_flag) { + if (private_module->use_hal_tdm) { if (private_module->use_default_type_bo == 1) - func_voutput->voutput_set_target_buffer_queue_flag(voutput_backend, TBM_BO_DEFAULT); + hal_tdm_voutput_set_target_buffer_queue_flag((hal_tdm_voutput *)voutput_backend, TBM_BO_DEFAULT); else - func_voutput->voutput_set_target_buffer_queue_flag(voutput_backend, TBM_BO_SCANOUT); + hal_tdm_voutput_set_target_buffer_queue_flag((hal_tdm_voutput *)voutput_backend, TBM_BO_SCANOUT); + } else { + if (func_voutput->voutput_set_target_buffer_queue_flag) { + if (private_module->use_default_type_bo == 1) + func_voutput->voutput_set_target_buffer_queue_flag(voutput_backend, TBM_BO_DEFAULT); + else + func_voutput->voutput_set_target_buffer_queue_flag(voutput_backend, TBM_BO_SCANOUT); + } } ret = tdm_display_update_output(private_display->current_module, output_backend); if (ret != TDM_ERROR_NONE) { TDM_ERR("tdm_display_update_output fail"); - free(private_voutput); - if (func_voutput->voutput_destroy) - func_voutput->voutput_destroy(voutput_backend); - else - TDM_ERR("no destroy function"); if (error) *error = ret; - private_display->current_module = current_module; - _pthread_mutex_unlock(&private_display->lock); - return NULL; + goto update_output_fail; } LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) { @@ -1141,10 +1137,14 @@ tdm_display_voutput_create(tdm_display *dpy, const char *name, tdm_error *error) if (output_find != 1) { private_output = NULL; free(private_voutput); - if (func_voutput->voutput_destroy) - func_voutput->voutput_destroy(voutput_backend); - else - TDM_ERR("no destroy function"); + if (private_module->use_hal_tdm) { + hal_tdm_voutput_destroy((hal_tdm_voutput *)voutput_backend); + } else { + if (func_voutput->voutput_destroy) + func_voutput->voutput_destroy(voutput_backend); + else + TDM_ERR("no destroy function"); + } private_voutput = NULL; } else { strncpy(private_voutput->name, name, TDM_NAME_LEN - 1); @@ -1166,5 +1166,22 @@ tdm_display_voutput_create(tdm_display *dpy, const char *name, tdm_error *error) _pthread_mutex_unlock(&private_display->lock); return private_voutput; + +update_output_fail: +output_get_fail: + if (private_module->use_hal_tdm) { + hal_tdm_voutput_destroy((hal_tdm_voutput *)voutput_backend); + } else { + if (func_voutput->voutput_destroy) + func_voutput->voutput_destroy(voutput_backend); + else + TDM_ERR("no destroy function"); + } +voutput_create_fail: + free(private_voutput); + private_display->current_module = current_module; + _pthread_mutex_unlock(&private_display->lock); + + return NULL; } /* LCOV_EXCL_STOP */ diff --git a/src/tdm_event_loop.c b/src/tdm_event_loop.c index 5117c27..0e0481e 100644 --- a/src/tdm_event_loop.c +++ b/src/tdm_event_loop.c @@ -73,14 +73,26 @@ _tdm_event_loop_main_fd_handler(int fd, tdm_event_loop_mask mask, void *user_dat if (tdm_debug_module & TDM_DEBUG_EVENT) TDM_INFO("backend fd(%d) event happens", private_module->fd); - func_display = &private_module->func_display; - if (!func_display->display_handle_events) - return TDM_ERROR_NONE; - - private_display = private_module->private_display; - private_display->current_module = private_module; - ret = func_display->display_handle_events(private_module->bdata); - private_display->current_module = NULL; + if (private_module->use_hal_tdm) { + tdm_private_module *current_module; + private_display = private_module->private_display; + current_module = private_display->current_module; + private_display->current_module = private_module; + ret = (tdm_error)hal_tdm_display_handle_events(private_module->htdm_backend); + if (ret == TDM_ERROR_NONE) + private_display->current_module = NULL; + else + private_display->current_module = current_module; + } else { + func_display = &private_module->func_display; + if (!func_display->display_handle_events) + return TDM_ERROR_NONE; + + private_display = private_module->private_display; + private_display->current_module = private_module; + ret = func_display->display_handle_events(private_module->bdata); + private_display->current_module = NULL; + } return ret; } @@ -200,19 +212,28 @@ tdm_event_loop_create_backend_source(tdm_private_display *private_display) TDM_RETURN_IF_FAIL(private_loop != NULL); LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { - tdm_func_display *func_display = &private_module->func_display; - - if (!func_display->display_get_fd) { - TDM_INFO("TDM backend module won't offer a display fd"); - private_module->event_source = NULL; - private_module->fd = -1; - continue; + if (private_module->use_hal_tdm) { + if (hal_tdm_display_get_fd(private_module->htdm_backend, &fd) != HAL_TDM_ERROR_NONE) { + TDM_INFO("TDM backend module won't offer a display fd"); + private_module->event_source = NULL; + private_module->fd = -1; + continue; + } + ret = TDM_ERROR_NONE; + } else { + tdm_func_display *func_display = &private_module->func_display; + + if (!func_display->display_get_fd) { + TDM_INFO("TDM backend module won't offer a display fd"); + private_module->event_source = NULL; + private_module->fd = -1; + continue; + } + + ret = func_display->display_get_fd(private_module->bdata, &fd); + assert(func_display->display_handle_events); } - - ret = func_display->display_get_fd(private_module->bdata, &fd); - assert(ret == TDM_ERROR_NONE && fd >= 0); - assert(func_display->display_handle_events); private_module->event_source = tdm_event_loop_add_fd_handler(private_display, fd, diff --git a/src/tdm_helper.c b/src/tdm_helper.c index 469f9b0..b2f5d77 100644 --- a/src/tdm_helper.c +++ b/src/tdm_helper.c @@ -824,10 +824,16 @@ _tdm_helper_get_backend_information(tdm_private_module *private_module, char *re TDM_SNPRINTF(reply, len, "\t\tname\ttype\tidx\tvalue\n"); for (i = 0; i < private_output->caps.prop_count; i++) { tdm_value value; - TDM_DBG_RETURN_VAL_IF_FAIL(func_output->output_get_property, reply); - ret = func_output->output_get_property(private_output->output_backend, - private_output->caps.props[i].id, - &value); + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_output_get_property(private_output->output_backend, + private_output->caps.props[i].id, + (hal_tdm_value *)&value); + } else { + TDM_DBG_RETURN_VAL_IF_FAIL(func_output->output_get_property, reply); + ret = func_output->output_get_property(private_output->output_backend, + private_output->caps.props[i].id, + &value); + } TDM_DBG_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, reply); TDM_SNPRINTF(reply, len, "\t\t%s\t%s\t%u\t", private_output->caps.props[i].name, diff --git a/src/tdm_hwc.c b/src/tdm_hwc.c index 76865e0..0c49873 100644 --- a/src/tdm_hwc.c +++ b/src/tdm_hwc.c @@ -194,6 +194,37 @@ _tdm_hwc_cb_commit(tdm_hwc *hwc_backend, unsigned int sequence, TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } +static void +_tdm_hwc_cb_commit_hal_tdm(hal_tdm_hwc *hwc_backend, unsigned int sequence, + unsigned int tv_sec, unsigned int tv_usec, void *user_data) +{ + tdm_private_hwc_commit_handler *hwc_commit_handler = user_data; + tdm_private_hwc *private_hwc; + tdm_thread_cb_hwc_commit hwc_commit; + tdm_error ret; + + if (hwc_commit_handler && hwc_commit_handler->use_vblank) + return; + + if (hwc_commit_handler) + private_hwc = hwc_commit_handler->private_hwc; + else + private_hwc = tdm_display_find_private_hwc(tdm_display_get(), (tdm_hwc *)hwc_backend); + + memset(&hwc_commit, 0, sizeof hwc_commit); + hwc_commit.base.type = TDM_THREAD_CB_HWC_COMMIT; + hwc_commit.base.length = sizeof hwc_commit; + hwc_commit.base.object_stamp = private_hwc->stamp; + hwc_commit.base.data = hwc_commit_handler; + hwc_commit.base.sync = 0; + hwc_commit.sequence = sequence; + hwc_commit.tv_sec = tv_sec; + hwc_commit.tv_usec = tv_usec; + + ret = tdm_thread_cb_call(private_hwc, &hwc_commit.base, 1); + TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); +} + /* LCOV_EXCL_START */ static void _tdm_hwc_got_wait_vblank(unsigned int sequence, @@ -341,16 +372,19 @@ tdm_hwc_get_video_supported_formats(tdm_hwc *hwc, const tbm_format **formats, in private_module = private_output->private_module; func_hwc = &private_module->func_hwc; - if (!func_hwc->hwc_get_video_supported_formats) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ - } - - ret = func_hwc->hwc_get_video_supported_formats(private_hwc->hwc_backend, formats, count); + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_hwc_get_video_supported_formats((hal_tdm_hwc *)private_hwc->hwc_backend, formats, count); + } else { + if (!func_hwc->hwc_get_video_supported_formats) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } + ret = func_hwc->hwc_get_video_supported_formats(private_hwc->hwc_backend, formats, count); + } _pthread_mutex_unlock(&private_display->lock); return ret; @@ -372,16 +406,20 @@ tdm_hwc_get_video_available_properties(tdm_hwc *hwc, const tdm_prop **props, int private_module = private_output->private_module; func_hwc = &private_module->func_hwc; - if (!func_hwc->hwc_get_video_available_properties) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ - } - - ret = func_hwc->hwc_get_video_available_properties(private_hwc->hwc_backend, props, count); + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_hwc_get_video_available_properties((hal_tdm_hwc *)private_hwc->hwc_backend, + (const hal_tdm_prop **)props, count); + } else { + if (!func_hwc->hwc_get_video_available_properties) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } + ret = func_hwc->hwc_get_video_available_properties(private_hwc->hwc_backend, props, count); + } _pthread_mutex_unlock(&private_display->lock); return ret; @@ -400,14 +438,17 @@ tdm_hwc_get_capabilities(tdm_hwc *hwc, tdm_hwc_capability *capabilities) private_module = private_output->private_module; func_hwc = &private_module->func_hwc; - if (!func_hwc->hwc_get_capabilities) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - ret = func_hwc->hwc_get_capabilities(private_hwc->hwc_backend, capabilities); + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_hwc_get_capabilities((hal_tdm_hwc *)private_hwc->hwc_backend, (hal_tdm_hwc_capability *)capabilities); + } else { + if (!func_hwc->hwc_get_capabilities) { + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + } + ret = func_hwc->hwc_get_capabilities(private_hwc->hwc_backend, capabilities); + } _pthread_mutex_unlock(&private_display->lock); return ret; @@ -429,16 +470,19 @@ tdm_hwc_get_available_properties(tdm_hwc *hwc, const tdm_prop **props, int *coun private_module = private_output->private_module; func_hwc = &private_module->func_hwc; - if (!func_hwc->hwc_get_available_properties) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ - } - - ret = func_hwc->hwc_get_available_properties(private_hwc->hwc_backend, props, count); + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_hwc_get_available_properties((hal_tdm_hwc *)private_hwc->hwc_backend, (const hal_tdm_prop **)props, count); + } else { + if (!func_hwc->hwc_get_available_properties) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } + ret = func_hwc->hwc_get_available_properties(private_hwc->hwc_backend, props, count); + } _pthread_mutex_unlock(&private_display->lock); return ret; @@ -458,16 +502,19 @@ tdm_hwc_get_client_target_buffer_queue(tdm_hwc *hwc, tdm_error *error) private_module = private_hwc->private_module; func_hwc = &private_module->func_hwc; - if (!func_hwc->hwc_get_client_target_buffer_queue) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return NULL; - /* LCOV_EXCL_STOP */ - } - - queue = func_hwc->hwc_get_client_target_buffer_queue(private_hwc->hwc_backend, error); + if (private_module->use_hal_tdm) { + queue = hal_tdm_hwc_get_client_target_buffer_queue((hal_tdm_hwc *)private_hwc->hwc_backend, (hal_tdm_error *)error); + } else { + if (!func_hwc->hwc_get_client_target_buffer_queue) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return NULL; + /* LCOV_EXCL_STOP */ + } + queue = func_hwc->hwc_get_client_target_buffer_queue(private_hwc->hwc_backend, error); + } _pthread_mutex_unlock(&private_display->lock); return queue; @@ -495,16 +542,21 @@ tdm_hwc_set_client_target_buffer(tdm_hwc *hwc, tbm_surface_h target_buffer, tdm_ private_module = private_hwc->private_module; func_hwc = &private_module->func_hwc; - if (!func_hwc->hwc_set_client_target_buffer) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ - } - - ret = func_hwc->hwc_set_client_target_buffer(private_hwc->hwc_backend, target_buffer, damage); + if (private_module->use_hal_tdm) { + hal_tdm_region hdamage; + memcpy(&hdamage, &damage, sizeof(hal_tdm_region)); + ret = (tdm_error)hal_tdm_hwc_set_client_target_buffer((hal_tdm_hwc *)private_hwc->hwc_backend, target_buffer, hdamage); + } else { + if (!func_hwc->hwc_set_client_target_buffer) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } + ret = func_hwc->hwc_set_client_target_buffer(private_hwc->hwc_backend, target_buffer, damage); + } if (private_hwc->display_target_buffer) { if (private_hwc->display_target_buffer != target_buffer) { tbm_surface_internal_unref(private_hwc->display_target_buffer); @@ -537,16 +589,19 @@ tdm_hwc_set_client_target_acquire_fence(tdm_hwc *hwc, int acquire_fence) private_module = private_hwc->private_module; func_hwc = &private_module->func_hwc; - if (!func_hwc->hwc_set_client_target_acquire_fence) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ - } - - ret = func_hwc->hwc_set_client_target_acquire_fence(private_hwc->hwc_backend, acquire_fence); + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_hwc_set_client_target_acquire_fence((hal_tdm_hwc *)private_hwc->hwc_backend, acquire_fence); + } else { + if (!func_hwc->hwc_set_client_target_acquire_fence) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } + ret = func_hwc->hwc_set_client_target_acquire_fence(private_hwc->hwc_backend, acquire_fence); + } _pthread_mutex_unlock(&private_display->lock); return ret; @@ -570,21 +625,29 @@ tdm_hwc_validate(tdm_hwc *hwc, tdm_hwc_window **composited_wnds, uint32_t num_wn private_module = private_hwc->private_module; func_hwc = &private_module->func_hwc; - if (!func_hwc->hwc_validate) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ - } + if (private_module->use_hal_tdm) { + if (num_wnds == 0) { + ret = (tdm_error)hal_tdm_hwc_validate((hal_tdm_hwc *)private_hwc->hwc_backend, NULL, 0, num_types); - if (num_wnds == 0) { - ret = func_hwc->hwc_validate(private_hwc->hwc_backend, NULL, 0, num_types); + _pthread_mutex_unlock(&private_display->lock); + return ret; + } + } else { + if (!func_hwc->hwc_validate) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } - _pthread_mutex_unlock(&private_display->lock); - return ret; - } + if (num_wnds == 0) { + ret = func_hwc->hwc_validate(private_hwc->hwc_backend, NULL, 0, num_types); + _pthread_mutex_unlock(&private_display->lock); + return ret; + } + } composited_wnds_backend = calloc(num_wnds, sizeof(tdm_hwc_window *)); if (!composited_wnds_backend) { /* LCOV_EXCL_START */ @@ -598,8 +661,12 @@ tdm_hwc_validate(tdm_hwc *hwc, tdm_hwc_window **composited_wnds, uint32_t num_wn for (i = 0; i < num_wnds; i++) composited_wnds_backend[i] = composited_wnds_frontend[i]->hwc_window_backend; - ret = func_hwc->hwc_validate(private_hwc->hwc_backend, composited_wnds_backend, - num_wnds, num_types); + if (private_module->use_hal_tdm) + ret = (tdm_error)hal_tdm_hwc_validate((hal_tdm_hwc *)private_hwc->hwc_backend, (hal_tdm_hwc_window **)composited_wnds_backend, + num_wnds, num_types); + else + ret = func_hwc->hwc_validate(private_hwc->hwc_backend, composited_wnds_backend, + num_wnds, num_types); free(composited_wnds_backend); @@ -627,16 +694,22 @@ tdm_hwc_get_changed_composition_types(tdm_hwc *hwc, uint32_t *num_elements, private_module = private_hwc->private_module; func_hwc = &private_module->func_hwc; - if (!func_hwc->hwc_get_changed_composition_types) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ - } + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_hwc_get_changed_composition_types((hal_tdm_hwc *)private_hwc->hwc_backend, num_elements, + (hal_tdm_hwc_window **)hwc_window, + (hal_tdm_hwc_window_composition *)composition_types); + } else { + if (!func_hwc->hwc_get_changed_composition_types) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } - ret = func_hwc->hwc_get_changed_composition_types(private_hwc->hwc_backend, - num_elements, hwc_window, composition_types); + ret = func_hwc->hwc_get_changed_composition_types(private_hwc->hwc_backend, + num_elements, hwc_window, composition_types); + } if (ret != TDM_ERROR_NONE) { /* LCOV_EXCL_START */ _pthread_mutex_unlock(&private_display->lock); @@ -682,16 +755,19 @@ tdm_hwc_accept_validation(tdm_hwc *hwc) private_module = private_hwc->private_module; func_hwc = &private_module->func_hwc; - if (!func_hwc->hwc_validate) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ - } - - ret = func_hwc->hwc_accept_validation(private_hwc->hwc_backend); + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_hwc_accept_validation((hal_tdm_hwc *)private_hwc->hwc_backend); + } else { + if (!func_hwc->hwc_validate) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } + ret = func_hwc->hwc_accept_validation(private_hwc->hwc_backend); + } _pthread_mutex_unlock(&private_display->lock); return ret; @@ -713,12 +789,14 @@ tdm_hwc_commit(tdm_hwc *hwc, int sync, tdm_hwc_commit_handler func, void *user_d private_module = private_hwc->private_module; func_hwc = &private_module->func_hwc; - if (!func_hwc->hwc_commit) { - /* LCOV_EXCL_START */ - TDM_WRN("not implemented!!"); - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ + if (!private_module->use_hal_tdm) { + if (!func_hwc->hwc_commit) { + /* LCOV_EXCL_START */ + TDM_WRN("not implemented!!"); + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } } //TODO: I am not sure yet whether we have to check the dpms at hwc_commit. @@ -745,7 +823,10 @@ tdm_hwc_commit(tdm_hwc *hwc, int sync, tdm_hwc_commit_handler func, void *user_d if (!private_hwc->regist_commit_cb) { private_hwc->regist_commit_cb = 1; - ret = func_hwc->hwc_set_commit_handler(private_hwc->hwc_backend, _tdm_hwc_cb_commit); + if (private_module->use_hal_tdm) + ret = (tdm_error)hal_tdm_hwc_set_commit_handler((hal_tdm_hwc *)private_hwc->hwc_backend, _tdm_hwc_cb_commit_hal_tdm); + else + ret = func_hwc->hwc_set_commit_handler(private_hwc->hwc_backend, _tdm_hwc_cb_commit); /* LCOV_EXCL_START */ if (ret != TDM_ERROR_NONE) { private_hwc->regist_commit_cb = 0; @@ -791,7 +872,10 @@ tdm_hwc_commit(tdm_hwc *hwc, int sync, tdm_hwc_commit_handler func, void *user_d } } - ret = func_hwc->hwc_commit(private_hwc->hwc_backend, sync, hwc_commit_handler); + if (private_module->use_hal_tdm) + ret = (tdm_error)hal_tdm_hwc_commit((hal_tdm_hwc *)private_hwc->hwc_backend, sync, hwc_commit_handler); + else + ret = func_hwc->hwc_commit(private_hwc->hwc_backend, sync, hwc_commit_handler); TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed); if (hwc_use_vblank) { @@ -842,16 +926,19 @@ tdm_hwc_get_commit_fence(tdm_hwc *hwc, int *commit_fence) private_module = private_hwc->private_module; func_hwc = &private_module->func_hwc; - if (!func_hwc->hwc_get_commit_fence) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ - } - - ret = func_hwc->hwc_get_commit_fence(private_hwc->hwc_backend, commit_fence); + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_hwc_get_commit_fence((hal_tdm_hwc *)private_hwc->hwc_backend, commit_fence); + } else { + if (!func_hwc->hwc_get_commit_fence) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } + ret = func_hwc->hwc_get_commit_fence(private_hwc->hwc_backend, commit_fence); + } _pthread_mutex_unlock(&private_display->lock); return ret; @@ -873,17 +960,21 @@ tdm_hwc_get_release_fences(tdm_hwc *hwc, uint32_t *num_elements, private_module = private_hwc->private_module; func_hwc = &private_module->func_hwc; - if (!func_hwc->hwc_get_release_fences) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ - } - - ret = func_hwc->hwc_get_release_fences(private_hwc->hwc_backend, num_elements, - hwc_windows, fences); + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_hwc_get_release_fences((hal_tdm_hwc *)private_hwc->hwc_backend, num_elements, + (hal_tdm_hwc_window **)hwc_windows, fences); + } else { + if (!func_hwc->hwc_get_release_fences) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } + ret = func_hwc->hwc_get_release_fences(private_hwc->hwc_backend, num_elements, + hwc_windows, fences); + } if (hwc_windows == NULL || fences == NULL) { _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; @@ -922,16 +1013,21 @@ tdm_hwc_set_property(tdm_hwc *hwc, uint32_t id, tdm_value value) private_module = private_hwc->private_module; func_hwc = &private_module->func_hwc; - if (!func_hwc->hwc_set_property) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ - } - - ret = func_hwc->hwc_set_property(private_hwc->hwc_backend, id, value); + if (private_module->use_hal_tdm) { + hal_tdm_value hvalue; + memcpy(&hvalue.ptr, &value.ptr, sizeof(hal_tdm_value)); + ret = (tdm_error)hal_tdm_hwc_set_property((hal_tdm_hwc *)private_hwc->hwc_backend, id, hvalue); + } else { + if (!func_hwc->hwc_set_property) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } + ret = func_hwc->hwc_set_property(private_hwc->hwc_backend, id, value); + } _pthread_mutex_unlock(&private_display->lock); return ret; @@ -950,16 +1046,21 @@ tdm_hwc_get_property(tdm_hwc *hwc, uint32_t id, tdm_value *value) private_module = private_hwc->private_module; func_hwc = &private_module->func_hwc; - if (!func_hwc->hwc_get_property) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ - } - - ret = func_hwc->hwc_get_property(private_hwc->hwc_backend, id, value); + if (private_module->use_hal_tdm) { + hal_tdm_value hvalue; + ret = (tdm_error)hal_tdm_hwc_get_property((hal_tdm_hwc *)private_hwc->hwc_backend, id, &hvalue); + memcpy(value->ptr, &hvalue.ptr, sizeof(tdm_value)); + } else { + if (!func_hwc->hwc_get_property) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } + ret = func_hwc->hwc_get_property(private_hwc->hwc_backend, id, value); + } _pthread_mutex_unlock(&private_display->lock); return ret; @@ -978,15 +1079,18 @@ tdm_hwc_get_commit_interval(tdm_hwc *hwc, tdm_hwc_commit_interval *refresh) private_module = private_hwc->private_module; func_hwc = &private_module->func_hwc; - /* LCOV_EXCL_START */ - if (!func_hwc->hwc_get_commit_interval) { - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - ret = func_hwc->hwc_get_commit_interval(private_hwc->hwc_backend, refresh); - /* LCOV_EXCL_STOP */ + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_hwc_get_commit_interval((hal_tdm_hwc *)private_hwc->hwc_backend, (hal_tdm_hwc_commit_interval *)refresh); + } else { + /* LCOV_EXCL_START */ + if (!func_hwc->hwc_get_commit_interval) { + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_NOT_IMPLEMENTED; + } + ret = func_hwc->hwc_get_commit_interval(private_hwc->hwc_backend, refresh); + /* LCOV_EXCL_STOP */ + } _pthread_mutex_unlock(&private_display->lock); return ret; diff --git a/src/tdm_hwc_window.c b/src/tdm_hwc_window.c index 953144e..157cefa 100644 --- a/src/tdm_hwc_window.c +++ b/src/tdm_hwc_window.c @@ -96,12 +96,14 @@ tdm_hwc_window_create_internal(tdm_private_hwc *private_hwc, tdm_error *error) TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL); - if (!func_hwc->hwc_create_window) { - /* LCOV_EXCL_START */ - if (error) - *error = TDM_ERROR_BAD_MODULE; - return NULL; - /* LCOV_EXCL_STOP */ + if (!private_module->use_hal_tdm) { + if (!func_hwc->hwc_create_window) { + /* LCOV_EXCL_START */ + if (error) + *error = TDM_ERROR_BAD_MODULE; + return NULL; + /* LCOV_EXCL_STOP */ + } } private_hwc_window = calloc(1, sizeof(tdm_private_hwc_window)); @@ -113,8 +115,10 @@ tdm_hwc_window_create_internal(tdm_private_hwc *private_hwc, tdm_error *error) return NULL; /* LCOV_EXCL_STOP */ } - - hwc_window_backend = func_hwc->hwc_create_window(private_hwc->hwc_backend, &ret); + if (private_module->use_hal_tdm) + hwc_window_backend = (tdm_hwc_window *)hal_tdm_hwc_create_window((hal_tdm_hwc *)private_hwc->hwc_backend, (hal_tdm_error *)&ret); + else + hwc_window_backend = func_hwc->hwc_create_window(private_hwc->hwc_backend, &ret); if (ret != TDM_ERROR_NONE) { free(private_hwc_window); if (error) @@ -155,8 +159,10 @@ tdm_hwc_window_destroy_internal(tdm_private_hwc_window *private_hwc_window) LIST_DEL(&private_hwc_window->link); - func_hwc_window = &private_module->func_hwc_window; - func_hwc_window->hwc_window_destroy(private_hwc_window->hwc_window_backend); + if (private_module->use_hal_tdm) + hal_tdm_hwc_window_destroy((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend); + else + func_hwc_window->hwc_window_destroy(private_hwc_window->hwc_window_backend); free(private_hwc_window); } @@ -198,17 +204,20 @@ tdm_hwc_window_acquire_buffer_queue(tdm_hwc_window *hwc_window, tdm_error *error private_module = private_output->private_module; func_hwc_window = &private_module->func_hwc_window; - if (!func_hwc_window->hwc_window_acquire_buffer_queue) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - if (error) - *error = TDM_ERROR_NOT_IMPLEMENTED; - return NULL; + if (private_module->use_hal_tdm) { + queue = hal_tdm_hwc_window_acquire_buffer_queue((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, (hal_tdm_error *)error); + } else { + if (!func_hwc_window->hwc_window_acquire_buffer_queue) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + if (error) + *error = TDM_ERROR_NOT_IMPLEMENTED; + return NULL; + } + + queue = func_hwc_window->hwc_window_acquire_buffer_queue(private_hwc_window->hwc_window_backend, error); } - - queue = func_hwc_window->hwc_window_acquire_buffer_queue(private_hwc_window->hwc_window_backend, error); - _pthread_mutex_unlock(&private_display->lock); return queue; @@ -239,14 +248,17 @@ tdm_hwc_window_release_buffer_queue(tdm_hwc_window *hwc_window, tbm_surface_queu private_module = private_output->private_module; func_hwc_window = &private_module->func_hwc_window; - if (!func_hwc_window->hwc_window_release_buffer_queue) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return; - } - - func_hwc_window->hwc_window_release_buffer_queue(private_hwc_window->hwc_window_backend, queue); + if (private_module->use_hal_tdm) { + hal_tdm_hwc_window_release_buffer_queue((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, queue); + } else { + if (!func_hwc_window->hwc_window_release_buffer_queue) { + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return; + } + func_hwc_window->hwc_window_release_buffer_queue(private_hwc_window->hwc_window_backend, queue); + } _pthread_mutex_unlock(&private_display->lock); return; @@ -268,13 +280,18 @@ tdm_hwc_window_set_composition_type(tdm_hwc_window *hwc_window, private_module = private_output->private_module; func_hwc_window = &private_module->func_hwc_window; - if (!func_hwc_window->hwc_window_set_composition_type) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_hwc_window_set_composition_type((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, + (tdm_hwc_window_composition)composition_type); + } else { + if (!func_hwc_window->hwc_window_set_composition_type) { + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + } + + ret = func_hwc_window->hwc_window_set_composition_type(private_hwc_window->hwc_window_backend, composition_type); } - - ret = func_hwc_window->hwc_window_set_composition_type(private_hwc_window->hwc_window_backend, composition_type); if (ret == TDM_ERROR_NONE) private_hwc_window->composition_type = composition_type; @@ -298,14 +315,19 @@ tdm_hwc_window_set_buffer_damage(tdm_hwc_window *hwc_window, tdm_region damage) private_module = private_output->private_module; func_hwc_window = &private_module->func_hwc_window; - if (!func_hwc_window->hwc_window_set_buffer_damage) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; + if (private_module->use_hal_tdm) { + hal_tdm_region hdamage; + memcpy(&hdamage, &damage, sizeof(hal_tdm_region)); + ret = (tdm_error)hal_tdm_hwc_window_set_buffer_damage((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, hdamage); + } else { + if (!func_hwc_window->hwc_window_set_buffer_damage) { + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + } + + ret = func_hwc_window->hwc_window_set_buffer_damage(private_hwc_window->hwc_window_backend, damage); } - - ret = func_hwc_window->hwc_window_set_buffer_damage(private_hwc_window->hwc_window_backend, damage); - _pthread_mutex_unlock(&private_display->lock); return ret; @@ -328,10 +350,12 @@ tdm_hwc_window_set_info(tdm_hwc_window *hwc_window, tdm_hwc_window_info *info) private_module = private_output->private_module; func_hwc_window = &private_module->func_hwc_window; - if (!func_hwc_window->hwc_window_set_info) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; + if (!private_module->use_hal_tdm) { + if (!func_hwc_window->hwc_window_set_info) { + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + } } if (info->src_config.format) @@ -348,7 +372,10 @@ tdm_hwc_window_set_info(tdm_hwc_window *hwc_window, tdm_hwc_window_info *info) info->dst_pos.w, info->dst_pos.h, info->transform); - ret = func_hwc_window->hwc_window_set_info(private_hwc_window->hwc_window_backend, info); + if (private_module->use_hal_tdm) + ret = hal_tdm_hwc_window_set_info((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, (hal_tdm_hwc_window_info *)info); + else + ret = func_hwc_window->hwc_window_set_info(private_hwc_window->hwc_window_backend, info); _pthread_mutex_unlock(&private_display->lock); @@ -375,13 +402,17 @@ tdm_hwc_window_set_buffer(tdm_hwc_window *hwc_window, tbm_surface_h buffer) private_module = private_output->private_module; func_hwc_window = &private_module->func_hwc_window; - if (!func_hwc_window->hwc_window_set_buffer) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } + if (private_module->use_hal_tdm) { + ret = hal_tdm_hwc_window_set_buffer((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, buffer); + } else { + if (!func_hwc_window->hwc_window_set_buffer) { + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + } - ret = func_hwc_window->hwc_window_set_buffer(private_hwc_window->hwc_window_backend, buffer); + ret = func_hwc_window->hwc_window_set_buffer(private_hwc_window->hwc_window_backend, buffer); + } if (ret == TDM_ERROR_NONE) private_hwc_window->display_buffer = buffer; @@ -403,14 +434,17 @@ tdm_hwc_window_set_acquire_fence(tdm_hwc_window *hwc_window, int acquire_fence) private_module = private_output->private_module; func_hwc_window = &private_module->func_hwc_window; - if (!func_hwc_window->hwc_window_set_acquire_fence) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - ret = func_hwc_window->hwc_window_set_acquire_fence(private_hwc_window->hwc_window_backend, acquire_fence); + if (private_module->use_hal_tdm) { + ret = hal_tdm_hwc_window_set_acquire_fence((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, acquire_fence); + } else { + if (!func_hwc_window->hwc_window_set_acquire_fence) { + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + } + ret = func_hwc_window->hwc_window_set_acquire_fence(private_hwc_window->hwc_window_backend, acquire_fence); + } _pthread_mutex_unlock(&private_display->lock); return ret; @@ -431,15 +465,20 @@ tdm_hwc_window_get_property(tdm_hwc_window *hwc_window, unsigned int id, tdm_val private_module = private_output->private_module; func_hwc_window = &private_module->func_hwc_window; - if (!func_hwc_window->hwc_window_get_property) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; + if (private_module->use_hal_tdm) { + hal_tdm_value hvalue; + ret = hal_tdm_hwc_window_get_property((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, id, &hvalue); + memcpy(value->ptr, &hvalue.ptr, sizeof(tdm_value)); + } else { + if (!func_hwc_window->hwc_window_get_property) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + } + + ret = func_hwc_window->hwc_window_get_property(private_hwc_window->hwc_window_backend, id, value); } - - ret = func_hwc_window->hwc_window_get_property(private_hwc_window->hwc_window_backend, id, value); - _pthread_mutex_unlock(&private_display->lock); return ret; @@ -458,15 +497,20 @@ tdm_hwc_window_set_property(tdm_hwc_window *hwc_window, unsigned int id, tdm_val private_module = private_output->private_module; func_hwc_window = &private_module->func_hwc_window; - if (!func_hwc_window->hwc_window_set_property) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; + if (private_module->use_hal_tdm) { + hal_tdm_value hvalue; + memcpy(&hvalue.ptr, &value.ptr, sizeof(hal_tdm_value)); + ret = hal_tdm_hwc_window_set_property((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, id, hvalue); + } else { + if (!func_hwc_window->hwc_window_set_property) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + } + + ret = func_hwc_window->hwc_window_set_property(private_hwc_window->hwc_window_backend, id, value); } - - ret = func_hwc_window->hwc_window_set_property(private_hwc_window->hwc_window_backend, id, value); - _pthread_mutex_unlock(&private_display->lock); return ret; @@ -485,14 +529,17 @@ tdm_hwc_window_get_constraints(tdm_hwc_window *hwc_window, int *constraints) private_module = private_output->private_module; func_hwc_window = &private_module->func_hwc_window; - if (!func_hwc_window->hwc_window_get_constraints) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - ret = func_hwc_window->hwc_window_get_constraints(private_hwc_window->hwc_window_backend, constraints); + if (private_module->use_hal_tdm) { + ret = hal_tdm_hwc_window_get_constraints((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, constraints); + } else { + if (!func_hwc_window->hwc_window_get_constraints) { + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + } + ret = func_hwc_window->hwc_window_get_constraints(private_hwc_window->hwc_window_backend, constraints); + } _pthread_mutex_unlock(&private_display->lock); return ret; @@ -511,14 +558,17 @@ tdm_hwc_window_set_name(tdm_hwc_window *hwc_window, const char *name) private_module = private_output->private_module; func_hwc_window = &private_module->func_hwc_window; - if (!func_hwc_window->hwc_window_set_name) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - ret = func_hwc_window->hwc_window_set_name(private_hwc_window->hwc_window_backend, name); + if (private_module->use_hal_tdm) { + ret = hal_tdm_hwc_window_set_name((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, name); + } else { + if (!func_hwc_window->hwc_window_set_name) { + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + } + ret = func_hwc_window->hwc_window_set_name(private_hwc_window->hwc_window_backend, name); + } _pthread_mutex_unlock(&private_display->lock); return ret; @@ -537,14 +587,17 @@ tdm_hwc_window_set_cursor_image(tdm_hwc_window *hwc_window, int width, int heigh private_module = private_output->private_module; func_hwc_window = &private_module->func_hwc_window; - if (!func_hwc_window->hwc_window_set_cursor_image) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - ret = func_hwc_window->hwc_window_set_cursor_image(private_hwc_window->hwc_window_backend, width, height, stride, ptr); + if (private_module->use_hal_tdm) { + ret = hal_tdm_hwc_window_set_cursor_image((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, width, height, stride, ptr); + } else { + if (!func_hwc_window->hwc_window_set_cursor_image) { + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + } + ret = func_hwc_window->hwc_window_set_cursor_image(private_hwc_window->hwc_window_backend, width, height, stride, ptr); + } _pthread_mutex_unlock(&private_display->lock); return ret; diff --git a/src/tdm_output.c b/src/tdm_output.c index c7cf2c6..bd2afa7 100644 --- a/src/tdm_output.c +++ b/src/tdm_output.c @@ -441,6 +441,44 @@ tdm_output_cb_dpms(tdm_output *output_backend, tdm_output_dpms dpms, void *user_ ret = _tdm_output_call_thread_cb_dpms(private_output, dpms); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } + +INTERN void +tdm_output_cb_status_hal_tdm(hal_tdm_output *output_backend, hal_tdm_output_conn_status status, void *user_data) +{ + tdm_private_output *private_output = user_data; + tdm_error ret; + + TDM_RETURN_IF_FAIL(private_output); + + TDM_INFO("output(%d) %s", private_output->pipe, tdm_status_str((tdm_output_conn_status)status)); + + if ((private_output->caps.status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED && status != HAL_TDM_OUTPUT_CONN_STATUS_DISCONNECTED) || + (private_output->caps.status != TDM_OUTPUT_CONN_STATUS_DISCONNECTED && status == HAL_TDM_OUTPUT_CONN_STATUS_DISCONNECTED)) { + ret = tdm_display_update_output(private_output->private_module, output_backend); + TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE); + } else { + private_output->caps.status = (tdm_output_conn_status)status; + } + + ret = _tdm_output_call_thread_cb_status(private_output, (tdm_output_conn_status)status); + TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); +} + +INTERN void +tdm_output_cb_dpms_hal_tdm(hal_tdm_output *output_backend, hal_tdm_output_dpms dpms, void *user_data) +{ + tdm_private_output *private_output = user_data; + tdm_error ret; + + TDM_INFO("output(%d) %s", private_output->pipe, tdm_dpms_str((tdm_output_dpms)dpms)); + + private_output->current_dpms_value = (tdm_output_dpms)dpms; + private_output->waiting_dpms_change = 0; + TDM_INFO("output(%d) DPMS async '%s' done", private_output->pipe, tdm_dpms_str((tdm_output_dpms)dpms)); + + ret = _tdm_output_call_thread_cb_dpms(private_output, (tdm_output_dpms)dpms); + TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); +} /* LCOV_EXCL_STOP */ EXTERN tdm_error @@ -872,18 +910,24 @@ tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value) _pthread_mutex_lock(&private_display->lock); private_module = private_output->private_module; - func_output = &private_module->func_output; - if (!func_output->output_set_property) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ - } + if (private_module->use_hal_tdm) { + hal_tdm_value hvalue; + memcpy(&hvalue.ptr, &value.ptr, sizeof(hal_tdm_value)); + ret = (tdm_error)hal_tdm_output_set_property(private_output->output_backend, id, hvalue); + } else { + func_output = &private_module->func_output; + + if (!func_output->output_set_property) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } - ret = func_output->output_set_property(private_output->output_backend, id, - value); + ret = func_output->output_set_property(private_output->output_backend, id, value); + } _pthread_mutex_unlock(&private_display->lock); @@ -902,19 +946,24 @@ tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value) _pthread_mutex_lock(&private_display->lock); private_module = private_output->private_module; - func_output = &private_module->func_output; - if (!func_output->output_get_property) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ - } + if (private_module->use_hal_tdm) { + hal_tdm_value hvalue; + ret = (tdm_error)hal_tdm_output_get_property(private_output->output_backend, id, &hvalue); + memcpy(value->ptr, &hvalue.ptr, sizeof(tdm_value)); + } else { + func_output = &private_module->func_output; - ret = func_output->output_get_property(private_output->output_backend, id, - value); + if (!func_output->output_get_property) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } + ret = func_output->output_get_property(private_output->output_backend, id, value); + } _pthread_mutex_unlock(&private_display->lock); return ret; @@ -1006,6 +1055,33 @@ _tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence, TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } +static void +_tdm_output_cb_vblank_hal_tdm(hal_tdm_output *output_backend, unsigned int sequence, + unsigned int tv_sec, unsigned int tv_usec, void *user_data) +{ + tdm_private_output_vblank_handler *vblank_handler = user_data; + tdm_thread_cb_output_vblank output_vblank; + tdm_error ret; + + memset(&output_vblank, 0, sizeof output_vblank); + output_vblank.base.type = TDM_THREAD_CB_OUTPUT_VBLANK; + output_vblank.base.length = sizeof output_vblank; + output_vblank.base.object_stamp = vblank_handler->private_output->stamp; + output_vblank.base.data = vblank_handler; + output_vblank.base.sync = 0; + output_vblank.sequence = sequence; + output_vblank.tv_sec = tv_sec; + output_vblank.tv_usec = tv_usec; + + 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, 1); + TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); +} + /* LCOV_EXCL_START */ static void _tdm_output_thread_cb_commit(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data) @@ -1082,6 +1158,34 @@ _tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence, ret = tdm_thread_cb_call(private_output, &output_commit.base, 1); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } + +static void +_tdm_output_cb_commit_hal_tdm(hal_tdm_output *output_backend, unsigned int sequence, + unsigned int tv_sec, unsigned int tv_usec, void *user_data) +{ + tdm_private_output_commit_handler *output_commit_handler = user_data; + tdm_private_output *private_output; + tdm_thread_cb_output_commit output_commit; + tdm_error ret; + + if (output_commit_handler) + private_output = output_commit_handler->private_output; + else + private_output = tdm_display_find_private_output(tdm_display_get(), (tdm_output *)output_backend); + + memset(&output_commit, 0, sizeof output_commit); + output_commit.base.type = TDM_THREAD_CB_OUTPUT_COMMIT; + output_commit.base.length = sizeof output_commit; + output_commit.base.object_stamp = private_output->stamp; + output_commit.base.data = output_commit_handler; + output_commit.base.sync = 0; + output_commit.sequence = sequence; + output_commit.tv_sec = tv_sec; + output_commit.tv_usec = tv_usec; + + ret = tdm_thread_cb_call(private_output, &output_commit.base, 1); + TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); +} /* LCOV_EXCL_STOP */ /* LCOV_EXCL_START */ @@ -1190,19 +1294,25 @@ _tdm_output_wait_vblank(tdm_private_output *private_output, int interval, int sy if (interval <= 0) interval = 1; - if (!func_output->output_wait_vblank) { - /* LCOV_EXCL_START */ - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ - } + if (private_module->use_hal_tdm) { + if (!private_output->regist_vblank_cb) { + private_output->regist_vblank_cb = 1; + ret = (tdm_error)hal_tdm_output_set_vblank_handler(private_output->output_backend, _tdm_output_cb_vblank_hal_tdm); + } + } else { + if (!func_output->output_wait_vblank) { + /* LCOV_EXCL_START */ + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } - if (!private_output->regist_vblank_cb) { - private_output->regist_vblank_cb = 1; - ret = func_output->output_set_vblank_handler(private_output->output_backend, - _tdm_output_cb_vblank); + if (!private_output->regist_vblank_cb) { + private_output->regist_vblank_cb = 1; + ret = func_output->output_set_vblank_handler(private_output->output_backend, + _tdm_output_cb_vblank); + } } - vblank_handler = calloc(1, sizeof(tdm_private_output_vblank_handler)); if (!vblank_handler) { /* LCOV_EXCL_START */ @@ -1240,9 +1350,12 @@ _tdm_output_wait_vblank(tdm_private_output *private_output, int interval, int sy TDM_ERR("tdm_thread_cb_add failed"); goto wait_failed; } - - ret = func_output->output_wait_vblank(private_output->output_backend, interval, - sync, vblank_handler); + if (private_module->use_hal_tdm) + ret = (tdm_error)hal_tdm_output_wait_vblank(private_output->output_backend, interval, + sync, vblank_handler); + else + ret = func_output->output_wait_vblank(private_output->output_backend, interval, + sync, vblank_handler); TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, wait_failed); _tdm_output_vblank_timeout_update(private_output, 1000); @@ -1565,9 +1678,11 @@ tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handl private_display = private_module->private_display; func_output = &private_module->func_output; - if (!func_output->output_commit) { - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; + if (!private_module->use_hal_tdm) { + if (!func_output->output_commit) { + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + } } ret = tdm_output_get_dpms_internal(output, &dpms_value); @@ -1576,7 +1691,10 @@ tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handl if (!TDM_OUTPUT_DPMS_VSYNC_IS_OFF(dpms_value)) { 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); + if (private_module->use_hal_tdm) + ret = (tdm_error)hal_tdm_output_set_commit_handler(private_output->output_backend, _tdm_output_cb_commit_hal_tdm); + else + 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); } @@ -1618,9 +1736,10 @@ tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handl voutput_commit_handler->user_data = private_layer->commiting_buffer; } } - - ret = func_output->output_commit(private_output->output_backend, sync, - output_commit_handler); + if (private_module->use_hal_tdm) + ret = (tdm_error)hal_tdm_output_commit(private_output->output_backend, sync, output_commit_handler); + else + ret = func_output->output_commit(private_output->output_backend, sync, output_commit_handler); TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed); if (tdm_debug_module & TDM_DEBUG_COMMIT) @@ -1735,15 +1854,19 @@ tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode) private_module = private_output->private_module; func_output = &private_module->func_output; - if (!func_output->output_set_mode) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ - } + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_output_set_mode(private_output->output_backend, (const hal_tdm_output_mode *)mode); + } else { + if (!func_output->output_set_mode) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } - ret = func_output->output_set_mode(private_output->output_backend, mode); + ret = func_output->output_set_mode(private_output->output_backend, mode); + } if (ret == TDM_ERROR_NONE) { private_output->current_mode = mode; private_output->need_set_target_info = 1; @@ -1804,17 +1927,19 @@ tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value) TDM_INFO("output(%d) DPMS '%s'", private_output->pipe, tdm_dpms_str(dpms_value)); - if (func_output->output_set_dpms) - ret = func_output->output_set_dpms(private_output->output_backend, dpms_value); - else { - /* LCOV_EXCL_START */ - ret = TDM_ERROR_NONE; - TDM_WRN("DPMS not implemented!!"); - goto done; - /* LCOV_EXCL_STOP */ + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_output_set_dpms(private_output->output_backend, (hal_tdm_output_dpms)dpms_value); + } else { + if (func_output->output_set_dpms) + ret = func_output->output_set_dpms(private_output->output_backend, dpms_value); + else { + /* LCOV_EXCL_START */ + ret = TDM_ERROR_NONE; + TDM_WRN("DPMS not implemented!!"); + /* LCOV_EXCL_STOP */ + } } -done: if (ret == TDM_ERROR_NONE) { if (private_output->current_dpms_value != dpms_value) { private_output->current_dpms_value = dpms_value; @@ -1872,22 +1997,28 @@ tdm_output_set_dpms_async(tdm_output *output, tdm_output_dpms dpms_value) private_module = private_output->private_module; func_output = &private_module->func_output; - if (!func_output->output_set_dpms_handler) { - TDM_WRN("not implemented DPMS: output_set_dpms_handler"); - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NOT_IMPLEMENTED; - } + if (!private_module->use_hal_tdm) { + if (!func_output->output_set_dpms_handler) { + TDM_WRN("not implemented DPMS: output_set_dpms_handler"); + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_NOT_IMPLEMENTED; + } - if (!func_output->output_set_dpms_async) { - TDM_WRN("not implemented DPMS: output_set_dpms_async"); - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NOT_IMPLEMENTED; + if (!func_output->output_set_dpms_async) { + TDM_WRN("not implemented DPMS: output_set_dpms_async"); + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_NOT_IMPLEMENTED; + } } if (!private_output->regist_dpms_cb) { private_output->regist_dpms_cb = 1; - ret = func_output->output_set_dpms_handler(private_output->output_backend, - tdm_output_cb_dpms, private_output); + if (private_module->use_hal_tdm) + ret = (tdm_error)hal_tdm_output_set_dpms_handler(private_output->output_backend, + tdm_output_cb_dpms_hal_tdm, private_output); + else + ret = func_output->output_set_dpms_handler(private_output->output_backend, + tdm_output_cb_dpms, private_output); if (ret != TDM_ERROR_NONE) { _pthread_mutex_unlock(&private_display->lock); TDM_ERR("Can't set the DPMS handler!!"); @@ -1897,7 +2028,10 @@ tdm_output_set_dpms_async(tdm_output *output, tdm_output_dpms dpms_value) TDM_INFO("output(%d) DPMS async '%s'", private_output->pipe, tdm_dpms_str(dpms_value)); - ret = func_output->output_set_dpms_async(private_output->output_backend, dpms_value, &sync); + if (private_module->use_hal_tdm) + ret = (tdm_error)hal_tdm_output_set_dpms_async(private_output->output_backend, (hal_tdm_output_dpms)dpms_value, &sync); + else + ret = func_output->output_set_dpms_async(private_output->output_backend, dpms_value, &sync); if (ret == TDM_ERROR_NONE) { if (sync) { @@ -1949,15 +2083,19 @@ tdm_output_get_dpms_internal(tdm_output *output, tdm_output_dpms *dpms_value) private_module = private_output->private_module; func_output = &private_module->func_output; - if (!func_output->output_get_dpms) { - /* LCOV_EXCL_START */ - *dpms_value = private_output->current_dpms_value; - TDM_WRN("DPMS get not implemented!!"); - return TDM_ERROR_NONE; - /* LCOV_EXCL_STOP */ - } + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_output_get_dpms(private_output->output_backend, (hal_tdm_output_dpms *)dpms_value); + } else { + if (!func_output->output_get_dpms) { + /* LCOV_EXCL_START */ + *dpms_value = private_output->current_dpms_value; + TDM_WRN("DPMS get not implemented!!"); + return TDM_ERROR_NONE; + /* LCOV_EXCL_STOP */ + } - ret = func_output->output_get_dpms(private_output->output_backend, dpms_value); + ret = func_output->output_get_dpms(private_output->output_backend, dpms_value); + } if (ret != TDM_ERROR_NONE) { /* LCOV_EXCL_START */ TDM_ERR("output get DPMS failed"); @@ -2099,15 +2237,21 @@ tdm_output_set_mirror(tdm_output *output, tdm_output *src_output, tdm_transform return TDM_ERROR_BAD_REQUEST; } - if (!func_output->output_set_mirror) { - TDM_WRN("not implemented!!"); - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NOT_IMPLEMENTED; + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_output_set_mirror((hal_tdm_output *)private_output->output_backend, + (hal_tdm_output *)private_src_output->output_backend, (hal_tdm_transform)transform); } + else { + if (!func_output->output_set_mirror) { + TDM_WRN("not implemented!!"); + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_NOT_IMPLEMENTED; + } - ret = func_output->output_set_mirror(private_output->output_backend, - private_src_output->output_backend, - transform); + ret = func_output->output_set_mirror(private_output->output_backend, + private_src_output->output_backend, + transform); + } if (ret != TDM_ERROR_NONE) { TDM_ERR("output(%p) fails to set MIRROR.", private_output); _pthread_mutex_unlock(&private_display->lock); @@ -2140,13 +2284,17 @@ tdm_output_unset_mirror(tdm_output *output) return TDM_ERROR_BAD_REQUEST; } - if (!func_output->output_unset_mirror) { - TDM_WRN("not implemented!!"); - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NOT_IMPLEMENTED; - } + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_output_unset_mirror((hal_tdm_output *)private_output->output_backend); + } else { + if (!func_output->output_unset_mirror) { + TDM_WRN("not implemented!!"); + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_NOT_IMPLEMENTED; + } - ret = func_output->output_unset_mirror(private_output->output_backend); + ret = func_output->output_unset_mirror(private_output->output_backend); + } if (ret != TDM_ERROR_NONE) { TDM_ERR("output(%p) fails to unset MIRROR.", private_output); _pthread_mutex_unlock(&private_display->lock); @@ -2234,12 +2382,16 @@ tdm_voutput_set_available_mode(tdm_voutput *voutput, const tdm_output_mode *mode _pthread_mutex_lock(&private_display->lock); - func_voutput = &private_module->func_voutput; - if (func_voutput->voutput_set_available_mode) - ret = func_voutput->voutput_set_available_mode(private_voutput->voutput_backend, modes, count); - else - ret = TDM_ERROR_NOT_IMPLEMENTED; - + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_voutput_set_available_mode((hal_tdm_voutput *)private_voutput->voutput_backend, + (const hal_tdm_output_mode *)modes, count); + } else { + func_voutput = &private_module->func_voutput; + if (func_voutput->voutput_set_available_mode) + ret = func_voutput->voutput_set_available_mode(private_voutput->voutput_backend, modes, count); + else + ret = TDM_ERROR_NOT_IMPLEMENTED; + } _pthread_mutex_unlock(&private_display->lock); return ret; @@ -2265,12 +2417,15 @@ tdm_voutput_set_physical_size(tdm_voutput *voutput, unsigned int mmwidth, unsign _pthread_mutex_lock(&private_display->lock); - func_voutput = &private_module->func_voutput; - if (func_voutput->voutput_set_physical_size) - ret = func_voutput->voutput_set_physical_size(private_voutput->voutput_backend, mmwidth, mmheight); - else - ret = TDM_ERROR_NOT_IMPLEMENTED; - + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_voutput_set_physical_size((hal_tdm_voutput *)private_voutput->voutput_backend, mmwidth, mmheight); + } else { + func_voutput = &private_module->func_voutput; + if (func_voutput->voutput_set_physical_size) + ret = func_voutput->voutput_set_physical_size(private_voutput->voutput_backend, mmwidth, mmheight); + else + ret = TDM_ERROR_NOT_IMPLEMENTED; + } _pthread_mutex_unlock(&private_display->lock); return ret; @@ -2294,12 +2449,15 @@ tdm_voutput_connect(tdm_voutput *voutput) _pthread_mutex_lock(&private_display->lock); - func_voutput = &private_module->func_voutput; - if (func_voutput->voutput_connect) - ret = func_voutput->voutput_connect(private_voutput->voutput_backend); - else - ret = TDM_ERROR_NOT_IMPLEMENTED; - + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_voutput_connect((hal_tdm_voutput *)private_voutput->voutput_backend); + } else { + func_voutput = &private_module->func_voutput; + if (func_voutput->voutput_connect) + ret = func_voutput->voutput_connect(private_voutput->voutput_backend); + else + ret = TDM_ERROR_NOT_IMPLEMENTED; + } _pthread_mutex_unlock(&private_display->lock); return ret; @@ -2323,12 +2481,15 @@ tdm_voutput_disconnect(tdm_voutput *voutput) _pthread_mutex_lock(&private_display->lock); - func_voutput = &private_module->func_voutput; - if (func_voutput->voutput_disconnect) - ret = func_voutput->voutput_disconnect(private_voutput->voutput_backend); - else - ret = TDM_ERROR_NOT_IMPLEMENTED; - + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_voutput_disconnect((hal_tdm_voutput *)private_voutput->voutput_backend); + } else { + func_voutput = &private_module->func_voutput; + if (func_voutput->voutput_disconnect) + ret = func_voutput->voutput_disconnect(private_voutput->voutput_backend); + else + ret = TDM_ERROR_NOT_IMPLEMENTED; + } _pthread_mutex_unlock(&private_display->lock); return ret; @@ -2350,12 +2511,16 @@ tdm_voutput_set_commit_func(tdm_voutput *voutput, tdm_voutput_commit_handler fun private_module = private_voutput->private_module; TDM_RETURN_VAL_IF_FAIL(private_module == private_display->virtual_module, TDM_ERROR_BAD_MODULE); - func_voutput = &private_module->func_voutput; - if (func_voutput->voutput_set_commit_func) - ret = func_voutput->voutput_set_commit_func(private_voutput->voutput_backend, func); - else - ret = TDM_ERROR_NOT_IMPLEMENTED; - + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_voutput_set_commit_func((hal_tdm_voutput *)private_voutput->voutput_backend, + (hal_tdm_voutput_commit_handler)func); + } else { + func_voutput = &private_module->func_voutput; + if (func_voutput->voutput_set_commit_func) + ret = func_voutput->voutput_set_commit_func(private_voutput->voutput_backend, func); + else + ret = TDM_ERROR_NOT_IMPLEMENTED; + } return ret; } @@ -2377,12 +2542,15 @@ tdm_voutput_commit_done(tdm_voutput *voutput) _pthread_mutex_lock(&private_display->lock); - func_voutput = &private_module->func_voutput; - if (func_voutput->voutput_commit_done) - ret = func_voutput->voutput_commit_done(private_voutput->voutput_backend); - else - ret = TDM_ERROR_NOT_IMPLEMENTED; - + if (private_module->use_hal_tdm) { + ret = (tdm_error)hal_tdm_voutput_commit_done((hal_tdm_voutput *)private_voutput->voutput_backend); + } else { + func_voutput = &private_module->func_voutput; + if (func_voutput->voutput_commit_done) + ret = func_voutput->voutput_commit_done(private_voutput->voutput_backend); + else + ret = TDM_ERROR_NOT_IMPLEMENTED; + } _pthread_mutex_unlock(&private_display->lock); return ret; diff --git a/src/tdm_pp.c b/src/tdm_pp.c index a53531a..c5396df 100644 --- a/src/tdm_pp.c +++ b/src/tdm_pp.c @@ -183,6 +183,28 @@ _tdm_pp_cb_done(tdm_pp *pp_module, tbm_surface_h src, tbm_surface_h dst, void *u TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } +static void +_tdm_pp_cb_done_hal_tdm(hal_tdm_pp *pp_module, tbm_surface_h src, tbm_surface_h dst, void *user_data) +{ + tdm_thread_cb_pp_done pp_done; + tdm_private_pp *private_pp = user_data; + tdm_error ret; + + TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED()); + + memset(&pp_done, 0, sizeof pp_done); + pp_done.base.type = TDM_THREAD_CB_PP_DONE; + pp_done.base.length = sizeof pp_done; + pp_done.base.object_stamp = private_pp->stamp; + pp_done.base.data = NULL; + pp_done.base.sync = 0; + pp_done.src = src; + pp_done.dst = dst; + + ret = tdm_thread_cb_call(private_pp, &pp_done.base, 1); + TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); +} + static void * _tdm_pp_find_object(tdm_private_display *private_display, double stamp) { @@ -222,22 +244,27 @@ tdm_pp_create_internal(tdm_private_module *private_module, tdm_error *error) TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL); TDM_RETURN_VAL_IF_FAIL(private_module != NULL, NULL); - private_display = private_module->private_display; - func_display = &private_module->func_display; - func_pp = &private_module->func_pp; - if (!(private_module->capabilities & TDM_DISPLAY_CAPABILITY_PP)) { /* LCOV_EXCL_START */ - TDM_ERR("backedn(%s) no pp capability", private_module->module_data->name); + TDM_ERR("backend no pp capability"); if (error) *error = TDM_ERROR_NO_CAPABILITY; return NULL; /* LCOV_EXCL_STOP */ } - pp_module = func_display->display_create_pp(private_module->bdata, &ret); + private_display = private_module->private_display; + func_display = &private_module->func_display; + func_pp = &private_module->func_pp; + + if (private_module->use_hal_tdm) { + pp_module = (tdm_pp *)hal_tdm_display_create_pp(private_module->htdm_backend, (hal_tdm_error *)&ret); + } else { + pp_module = func_display->display_create_pp(private_module->bdata, &ret); + } if (ret != TDM_ERROR_NONE) { /* LCOV_EXCL_START */ + TDM_ERR("create pp fail"); if (error) *error = ret; return NULL; @@ -247,33 +274,33 @@ tdm_pp_create_internal(tdm_private_module *private_module, tdm_error *error) private_pp = calloc(1, sizeof(tdm_private_pp)); if (!private_pp) { /* LCOV_EXCL_START */ - TDM_ERR("failed: alloc memory"); - func_pp->pp_destroy(pp_module); + TDM_ERR("memory alloc fail"); if (error) *error = TDM_ERROR_OUT_OF_MEMORY; - return NULL; + goto alloc_fail; /* LCOV_EXCL_STOP */ } ret = tdm_thread_cb_add(private_pp, TDM_THREAD_CB_PP_DONE, NULL, _tdm_pp_thread_cb_done, NULL); if (ret != TDM_ERROR_NONE) { + /* LCOV_EXCL_START */ TDM_ERR("pp tdm_thread_cb_add failed"); - func_pp->pp_destroy(pp_module); - free(private_pp); if (error) *error = ret; - return NULL; + goto thread_fail; + /* LCOV_EXCL_STOP */ } - ret = func_pp->pp_set_done_handler(pp_module, _tdm_pp_cb_done, private_pp); + if (private_module->use_hal_tdm) + ret = (tdm_error)hal_tdm_pp_set_done_handler((hal_tdm_pp *)pp_module, _tdm_pp_cb_done_hal_tdm, private_pp); + else + ret = func_pp->pp_set_done_handler(pp_module, _tdm_pp_cb_done, private_pp); if (ret != TDM_ERROR_NONE) { /* LCOV_EXCL_START */ TDM_ERR("spp(%p) et pp_done_handler failed", private_pp); - func_pp->pp_destroy(pp_module); - free(private_pp); if (error) *error = ret; - return NULL; + goto thread_fail; /* LCOV_EXCL_STOP */ } @@ -294,6 +321,16 @@ tdm_pp_create_internal(tdm_private_module *private_module, tdm_error *error) *error = TDM_ERROR_NONE; return private_pp; + +thread_fail: + free(private_pp); +alloc_fail: + if (private_module->use_hal_tdm) + hal_tdm_pp_destroy((hal_tdm_pp *)pp_module); + else + func_pp->pp_destroy(pp_module); + + return NULL; } INTERN void @@ -318,7 +355,10 @@ tdm_pp_destroy_internal(tdm_private_pp *private_pp) LIST_DEL(&private_pp->link); - func_pp->pp_destroy(private_pp->pp_module); + if (private_module->use_hal_tdm) + hal_tdm_pp_destroy((hal_tdm_pp *)private_pp->pp_module); + else + func_pp->pp_destroy(private_pp->pp_module); if (!LIST_IS_EMPTY(&private_pp->pending_buffer_list)) { TDM_WRN("pp(%p) not finished:", private_pp); @@ -401,12 +441,14 @@ tdm_pp_set_info(tdm_pp *pp, tdm_info_pp *info) _pthread_mutex_lock(&private_display->lock); - if (!func_pp->pp_set_info) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_DBG("failed: not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ + if (!private_module->use_hal_tdm) { + if (!func_pp->pp_set_info) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } } TDM_INFO("pp(%p) info: src(%ux%u %u,%u %ux%u %c%c%c%c) dst(%ux%u %u,%u %ux%u %c%c%c%c) trans(%d) sync(%d) flags(%x)", @@ -420,7 +462,10 @@ tdm_pp_set_info(tdm_pp *pp, tdm_info_pp *info) FOURCC_STR(info->dst_config.format), info->transform, info->sync, info->flags); - ret = func_pp->pp_set_info(private_pp->pp_module, info); + if (private_module->use_hal_tdm) + ret = (tdm_error)hal_tdm_pp_set_info((hal_tdm_pp *)private_pp->pp_module, (hal_tdm_info_pp *)info); + else + ret = func_pp->pp_set_info(private_pp->pp_module, info); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); private_pp->info = *info; @@ -466,12 +511,14 @@ tdm_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst) _pthread_mutex_lock(&private_display->lock); - if (!func_pp->pp_attach) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_DBG("failed: not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ + if (!private_module->use_hal_tdm) { + if (!func_pp->pp_attach) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } } if (tdm_module_check_abi(private_module, 1, 2) && @@ -506,7 +553,10 @@ tdm_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst) /* LCOV_EXCL_STOP */ } - ret = func_pp->pp_attach(private_pp->pp_module, src, dst); + if (private_module->use_hal_tdm) + ret = (tdm_error)hal_tdm_pp_attach((hal_tdm_pp *)private_pp->pp_module, src, dst); + else + ret = func_pp->pp_attach(private_pp->pp_module, src, dst); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); if (ret != TDM_ERROR_NONE) { @@ -547,12 +597,14 @@ tdm_pp_commit(tdm_pp *pp) _pthread_mutex_lock(&private_display->lock); - if (!func_pp->pp_commit) { - /* LCOV_EXCL_START */ - _pthread_mutex_unlock(&private_display->lock); - TDM_DBG("failed: not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - /* LCOV_EXCL_STOP */ + if (!private_module->use_hal_tdm) { + if (!func_pp->pp_commit) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } } LIST_INITHEAD(&commit_buffer_list); @@ -563,7 +615,10 @@ tdm_pp_commit(tdm_pp *pp) LIST_ADDTAIL(&b->commit_link, &commit_buffer_list); } - ret = func_pp->pp_commit(private_pp->pp_module); + if (private_module->use_hal_tdm) + ret = (tdm_error)hal_tdm_pp_commit((hal_tdm_pp *)private_pp->pp_module); + else + ret = func_pp->pp_commit(private_pp->pp_module); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); LIST_FOR_EACH_ENTRY_SAFE(b, bb, &commit_buffer_list, commit_link) { diff --git a/src/tdm_private.h b/src/tdm_private.h index 6788ba1..10f3cf3 100644 --- a/src/tdm_private.h +++ b/src/tdm_private.h @@ -120,6 +120,10 @@ tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status, void tdm_output_cb_dpms(tdm_output *output_backend, tdm_output_dpms dpms, void *user_data); +void +tdm_output_cb_status_hal_tdm(hal_tdm_output *output_backend, hal_tdm_output_conn_status status, void *user_data); +void +tdm_output_cb_dpms_hal_tdm(hal_tdm_output *output_backend, hal_tdm_output_dpms dpms, void *user_data); void tdm_output_vblank_print_wait_information(tdm_private_output *private_output, void *user_data); diff --git a/src/tdm_private_types.h b/src/tdm_private_types.h index b68e229..1bc8d1b 100644 --- a/src/tdm_private_types.h +++ b/src/tdm_private_types.h @@ -39,6 +39,7 @@ #include #include #include +#include #include "tdm_types.h" #include "tdm_list.h" @@ -160,6 +161,12 @@ struct _tdm_private_module { /* backend virtual output target buffer type default set for hwc */ int use_default_type_bo; + + /* hal tdm */ + int use_hal_tdm; + hal_tdm_backend *htdm_backend; + hal_tdm_display *htdm_dpy; + tdm_event_loop_source *htdm_event_source; }; struct _tdm_private_display { -- 2.7.4 From 8cdb02cd2defb29c91bd7e4d569ea43bba042a18 Mon Sep 17 00:00:00 2001 From: Junkyeong Kim Date: Sun, 7 Feb 2021 16:50:52 +0900 Subject: [PATCH 12/16] fix syntax error Change-Id: I19decd00bd7ec6ff0712f4adb69b4ee77f267e6b Signed-off-by: Junkyeong Kim --- src/tdm.c | 4 ++-- src/tdm_display.c | 2 +- src/tdm_event_loop.c | 4 ++-- src/tdm_pp.c | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/tdm.c b/src/tdm.c index 77a7f9d..3a37cd8 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -697,7 +697,7 @@ _tdm_display_get_ordered_outputs(tdm_private_module *private_module, int *count) } if (private_module->use_hal_tdm) - outputs = (tdm_output **)hal_tdm_display_get_outputs(private_module->htdm_backend, &output_count, (hal_tdm_error *)&ret); + outputs = (tdm_output **)hal_tdm_display_get_outputs(private_module->htdm_dpy, &output_count, (hal_tdm_error *)&ret); else outputs = func_display->display_get_outputs(private_module->bdata, &output_count, &ret); if (ret != TDM_ERROR_NONE) @@ -920,7 +920,7 @@ _tdm_display_load_hal_backend(tdm_private_display *private_display) hal_tdm = hal_tdm_get_backend(&hret); if (hal_tdm == NULL || hret != HAL_TDM_ERROR_NONE) { - TDM_INIT_INFO("failed hal_tdm_get_backend"); + TDM_ERR("failed hal_tdm_get_backend"); return TDM_ERROR_NO_MODULE; } diff --git a/src/tdm_display.c b/src/tdm_display.c index 49c8451..0ab009a 100644 --- a/src/tdm_display.c +++ b/src/tdm_display.c @@ -1080,7 +1080,7 @@ tdm_display_voutput_create(tdm_display *dpy, const char *name, tdm_error *error) private_display->current_module = private_module; if (private_module->use_hal_tdm) { - voutput_backend = (tdm_voutput *)hal_tdm_display_voutput_create(private_module->htdm_backend, name, (hal_tdm_error *)&ret); + voutput_backend = (tdm_voutput *)hal_tdm_display_voutput_create(private_module->htdm_dpy, name, (hal_tdm_error *)&ret); } else { func_display = &private_module->func_display; func_voutput = &private_module->func_voutput; diff --git a/src/tdm_event_loop.c b/src/tdm_event_loop.c index 0e0481e..495ef60 100644 --- a/src/tdm_event_loop.c +++ b/src/tdm_event_loop.c @@ -78,7 +78,7 @@ _tdm_event_loop_main_fd_handler(int fd, tdm_event_loop_mask mask, void *user_dat private_display = private_module->private_display; current_module = private_display->current_module; private_display->current_module = private_module; - ret = (tdm_error)hal_tdm_display_handle_events(private_module->htdm_backend); + ret = (tdm_error)hal_tdm_display_handle_events(private_module->htdm_dpy); if (ret == TDM_ERROR_NONE) private_display->current_module = NULL; else @@ -213,7 +213,7 @@ tdm_event_loop_create_backend_source(tdm_private_display *private_display) LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { if (private_module->use_hal_tdm) { - if (hal_tdm_display_get_fd(private_module->htdm_backend, &fd) != HAL_TDM_ERROR_NONE) { + if (hal_tdm_display_get_fd(private_module->htdm_dpy, &fd) != HAL_TDM_ERROR_NONE) { TDM_INFO("TDM backend module won't offer a display fd"); private_module->event_source = NULL; private_module->fd = -1; diff --git a/src/tdm_pp.c b/src/tdm_pp.c index c5396df..ea3f5f0 100644 --- a/src/tdm_pp.c +++ b/src/tdm_pp.c @@ -258,7 +258,7 @@ tdm_pp_create_internal(tdm_private_module *private_module, tdm_error *error) func_pp = &private_module->func_pp; if (private_module->use_hal_tdm) { - pp_module = (tdm_pp *)hal_tdm_display_create_pp(private_module->htdm_backend, (hal_tdm_error *)&ret); + pp_module = (tdm_pp *)hal_tdm_display_create_pp(private_module->htdm_dpy, (hal_tdm_error *)&ret); } else { pp_module = func_display->display_create_pp(private_module->bdata, &ret); } -- 2.7.4 From 2be2291fe15ad71e0388e7a058f587badc798127 Mon Sep 17 00:00:00 2001 From: Junkyeong Kim Date: Sun, 7 Feb 2021 17:59:14 +0900 Subject: [PATCH 13/16] do not use module_data if using hal-tdm Change-Id: I76484c8202d435f63f43fde8f3775f3910d81c87 Signed-off-by: Junkyeong Kim --- src/tdm_display.c | 55 ++++++++++++++++++++++++++++++------------------------- src/tdm_helper.c | 25 +++++++++++++------------ 2 files changed, 43 insertions(+), 37 deletions(-) diff --git a/src/tdm_display.c b/src/tdm_display.c index 0ab009a..a7a44f7 100644 --- a/src/tdm_display.c +++ b/src/tdm_display.c @@ -969,17 +969,18 @@ tdm_display_get_backend_info(tdm_display *dpy, const char **name, break; } - assert(module_data != NULL); - - if (name) - *name = module_data->name; - if (vendor) - *vendor = module_data->vendor; - if (major) - *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version); - if (minor) - *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version); - + if (!private_module->use_hal_tdm) { + assert(module_data != NULL); + + if (name) + *name = module_data->name; + if (vendor) + *vendor = module_data->vendor; + if (major) + *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version); + if (minor) + *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version); + } _pthread_mutex_unlock(&private_display->lock); return ret; @@ -1013,14 +1014,16 @@ tdm_module_get_info(tdm_module *module, const char **name, module_data = private_module->module_data; - if (name) - *name = module_data->name; - if (vendor) - *vendor = module_data->vendor; - if (major) - *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version); - if (minor) - *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version); + if (!private_module->use_hal_tdm) { + if (name) + *name = module_data->name; + if (vendor) + *vendor = module_data->vendor; + if (major) + *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version); + if (minor) + *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version); + } _pthread_mutex_unlock(&private_display->lock); @@ -1032,14 +1035,16 @@ tdm_module_check_abi(tdm_private_module *private_module, int abimaj, int abimin) { tdm_backend_module *module = private_module->module_data; - if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) > abimaj) - return 1; + if (!private_module->use_hal_tdm) { + if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) > abimaj) + return 1; - if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) < abimaj) - return 0; + if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) < abimaj) + return 0; - if (TDM_BACKEND_GET_ABI_MINOR(module->abi_version) < abimin) - return 0; + if (TDM_BACKEND_GET_ABI_MINOR(module->abi_version) < abimin) + return 0; + } return 1; } diff --git a/src/tdm_helper.c b/src/tdm_helper.c index b2f5d77..2990bd8 100644 --- a/src/tdm_helper.c +++ b/src/tdm_helper.c @@ -766,14 +766,15 @@ _tdm_helper_get_backend_information(tdm_private_module *private_module, char *re /* module information */ module_data = private_module->module_data; - TDM_SNPRINTF(reply, len, "['%s' backend information]\n", module_data->name); - TDM_SNPRINTF(reply, len, "vendor: %s\n", module_data->vendor); - TDM_SNPRINTF(reply, len, "version: %d.%d\n\n", - (int)TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version), - (int)TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version)); - + if (!private_module->use_hal_tdm) { + TDM_SNPRINTF(reply, len, "['%s' backend information]\n", module_data->name); + TDM_SNPRINTF(reply, len, "vendor: %s\n", module_data->vendor); + TDM_SNPRINTF(reply, len, "version: %d.%d\n\n", + (int)TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version), + (int)TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version)); + } /* output information */ - TDM_SNPRINTF(reply, len, "['%s' backend output information]\n", module_data->name); + TDM_SNPRINTF(reply, len, "['%s' backend output information]\n", module_data ? module_data->name : "hal-tdm"); TDM_SNPRINTF(reply, len, "--------------------------------------------------------------------------------------------\n"); TDM_SNPRINTF(reply, len, "idx maker model name type status dpms subpixel align_w min max phy(mm)\n"); TDM_SNPRINTF(reply, len, "--------------------------------------------------------------------------------------------\n"); @@ -865,7 +866,7 @@ _tdm_helper_get_backend_information(tdm_private_module *private_module, char *re TDM_SNPRINTF(reply, len, "\n"); /* layer information */ - TDM_SNPRINTF(reply, len, "['%s' backend layer information]\n", module_data->name); + TDM_SNPRINTF(reply, len, "['%s' backend layer information]\n", module_data ? module_data->name : "hal-tdm"); TDM_SNPRINTF(reply, len, "-----------------------------------------------------------------------\n"); TDM_SNPRINTF(reply, len, "idx output zpos buf format size crop geometry transform\n"); TDM_SNPRINTF(reply, len, "-----------------------------------------------------------------------\n"); @@ -972,7 +973,7 @@ _tdm_helper_get_backend_information(tdm_private_module *private_module, char *re if (private_module->capabilities & TDM_DISPLAY_CAPABILITY_PP) { const char *sep = ""; - TDM_SNPRINTF(reply, len, "['%s' backend PP information]\n", module_data->name); + TDM_SNPRINTF(reply, len, "['%s' backend PP information]\n", module_data ? module_data->name : "hal-tdm"); TDM_SNPRINTF(reply, len, "caps\t: "); tdm_pp_caps_str(private_module->caps_pp.capabilities, &reply, len); TDM_SNPRINTF(reply, len, "\n"); @@ -1010,13 +1011,13 @@ _tdm_helper_get_backend_information(tdm_private_module *private_module, char *re } } } else { - TDM_SNPRINTF(reply, len, "['%s' backend No PP capability]\n", module_data->name); + TDM_SNPRINTF(reply, len, "['%s' backend No PP capability]\n", module_data ? module_data->name : "hal-tdm"); } TDM_SNPRINTF(reply, len, "\n"); if (private_module->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE) { const char *sep = ""; - TDM_SNPRINTF(reply, len, "['%s' backend capture information]\n", module_data->name); + TDM_SNPRINTF(reply, len, "['%s' backend capture information]\n", module_data ? module_data->name : "hal-tdm"); TDM_SNPRINTF(reply, len, "caps\t: "); tdm_capture_caps_str(private_module->caps_capture.capabilities, &reply, len); TDM_SNPRINTF(reply, len, "\n"); @@ -1049,7 +1050,7 @@ _tdm_helper_get_backend_information(tdm_private_module *private_module, char *re } } } else { - TDM_SNPRINTF(reply, len, "['%s' backend No Capture capability]\n", module_data->name); + TDM_SNPRINTF(reply, len, "['%s' backend No Capture capability]\n", module_data ? module_data->name : "hal-tdm"); } TDM_SNPRINTF(reply, len, "\n"); return reply; -- 2.7.4 From c07cdc43648aa868455d1cba61a7803b001af2f9 Mon Sep 17 00:00:00 2001 From: Junkyeong Kim Date: Sun, 7 Feb 2021 18:23:59 +0900 Subject: [PATCH 14/16] execute memcpy only success case Change-Id: Ib730cb1dba433bf708743766680bb566ad91e112 Signed-off-by: Junkyeong Kim --- src/tdm_hwc.c | 3 ++- src/tdm_hwc_window.c | 3 ++- src/tdm_output.c | 3 ++- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/src/tdm_hwc.c b/src/tdm_hwc.c index 0c49873..11a7d5d 100644 --- a/src/tdm_hwc.c +++ b/src/tdm_hwc.c @@ -1049,7 +1049,8 @@ tdm_hwc_get_property(tdm_hwc *hwc, uint32_t id, tdm_value *value) if (private_module->use_hal_tdm) { hal_tdm_value hvalue; ret = (tdm_error)hal_tdm_hwc_get_property((hal_tdm_hwc *)private_hwc->hwc_backend, id, &hvalue); - memcpy(value->ptr, &hvalue.ptr, sizeof(tdm_value)); + if (ret == TDM_ERROR_NONE) + memcpy(&value->ptr, &hvalue.ptr, sizeof(tdm_value)); } else { if (!func_hwc->hwc_get_property) { /* LCOV_EXCL_START */ diff --git a/src/tdm_hwc_window.c b/src/tdm_hwc_window.c index 157cefa..074131d 100644 --- a/src/tdm_hwc_window.c +++ b/src/tdm_hwc_window.c @@ -468,7 +468,8 @@ tdm_hwc_window_get_property(tdm_hwc_window *hwc_window, unsigned int id, tdm_val if (private_module->use_hal_tdm) { hal_tdm_value hvalue; ret = hal_tdm_hwc_window_get_property((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, id, &hvalue); - memcpy(value->ptr, &hvalue.ptr, sizeof(tdm_value)); + if (ret == TDM_ERROR_NONE) + memcpy(&value->ptr, &hvalue.ptr, sizeof(tdm_value)); } else { if (!func_hwc_window->hwc_window_get_property) { /* LCOV_EXCL_START */ diff --git a/src/tdm_output.c b/src/tdm_output.c index bd2afa7..9232de9 100644 --- a/src/tdm_output.c +++ b/src/tdm_output.c @@ -950,7 +950,8 @@ tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value) if (private_module->use_hal_tdm) { hal_tdm_value hvalue; ret = (tdm_error)hal_tdm_output_get_property(private_output->output_backend, id, &hvalue); - memcpy(value->ptr, &hvalue.ptr, sizeof(tdm_value)); + if (ret == TDM_ERROR_NONE) + memcpy(&value->ptr, &hvalue.ptr, sizeof(tdm_value)); } else { func_output = &private_module->func_output; -- 2.7.4 From e3a3b08ff110a59d824f6bda40c3e35feae0eefa Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Sun, 7 Feb 2021 19:05:31 +0900 Subject: [PATCH 15/16] haltests: use EXPECT intead of ASSERT TearDown is not called at testcase failed when it uses ASSERT. Change-Id: Id6da7da47265a1aac9e72c628a411bf0ea0c4e2e --- haltests/src/tc_tdm_backend_capture.cpp | 224 +++++----- haltests/src/tc_tdm_backend_display.cpp | 496 +++++++++++----------- haltests/src/tc_tdm_backend_pp.cpp | 218 +++++----- haltests/src/tc_tdm_buffer.cpp | 78 ++-- haltests/src/tc_tdm_client.cpp | 712 ++++++++++++++++---------------- haltests/src/tc_tdm_display.cpp | 202 ++++----- haltests/src/tc_tdm_env.cpp | 20 +- haltests/src/tc_tdm_event_loop.cpp | 54 +-- haltests/src/tc_tdm_helper.cpp | 100 ++--- haltests/src/tc_tdm_hwc.cpp | 186 ++++----- haltests/src/tc_tdm_hwc_window.cpp | 78 ++-- haltests/src/tc_tdm_layer.cpp | 324 +++++++-------- haltests/src/tc_tdm_output.cpp | 592 +++++++++++++------------- haltests/src/tc_tdm_vblank.cpp | 564 ++++++++++++------------- 14 files changed, 1924 insertions(+), 1924 deletions(-) diff --git a/haltests/src/tc_tdm_backend_capture.cpp b/haltests/src/tc_tdm_backend_capture.cpp index 006430e..4b9f941 100644 --- a/haltests/src/tc_tdm_backend_capture.cpp +++ b/haltests/src/tc_tdm_backend_capture.cpp @@ -108,29 +108,29 @@ void TDMBackendCapture::SetUp(void) TDMBackendDisplay::SetUp(); - ASSERT_EQ(tdm_display_get_capabilities(dpy, &dpy_capabilities), TDM_ERROR_NONE); + EXPECT_EQ(tdm_display_get_capabilities(dpy, &dpy_capabilities), TDM_ERROR_NONE); has_capture_cap = dpy_capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE; if (!has_capture_cap) return; - ASSERT_EQ(tdm_display_get_capture_capabilities(dpy, &capabilities), TDM_ERROR_NONE); - ASSERT_GT(capabilities, 0); - ASSERT_EQ(tdm_display_get_capture_available_formats(dpy, &formats, &format_count), TDM_ERROR_NONE); - ASSERT_NE(formats, NULL); - ASSERT_GT(format_count, 0); - ASSERT_EQ(tdm_display_get_capture_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); - ASSERT_TRUE(max_h == -1 || max_h > 0); - ASSERT_TRUE(preferred_align == -1 || preferred_align > 0); + EXPECT_EQ(tdm_display_get_capture_capabilities(dpy, &capabilities), TDM_ERROR_NONE); + EXPECT_GT(capabilities, 0); + EXPECT_EQ(tdm_display_get_capture_available_formats(dpy, &formats, &format_count), TDM_ERROR_NONE); + EXPECT_NE(formats, NULL); + EXPECT_GT(format_count, 0); + EXPECT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE); + EXPECT_TRUE(min_w == -1 || min_w > 0); + EXPECT_TRUE(min_h == -1 || min_h > 0); + EXPECT_TRUE(max_w == -1 || max_w > 0); + EXPECT_TRUE(max_h == -1 || max_h > 0); + EXPECT_TRUE(preferred_align == -1 || preferred_align > 0); for (int o = 0; o < output_count; o++) { if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); } } @@ -143,7 +143,7 @@ void TDMBackendCapture::TearDown(void) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true); + EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true); } DestroyBuffers(); @@ -293,17 +293,17 @@ void TDMBackendCapture::DumpBuffer(int b, char *test) void TDMBackendCapture::ShowBuffer(int b, tdm_pos *pos) { - ASSERT_NE(output, NULL); - ASSERT_NE(dst_layer, NULL); + EXPECT_NE(output, NULL); + EXPECT_NE(dst_layer, NULL); - ASSERT_EQ(tc_tdm_layer_set_buffer_with_pos(dst_layer, buffers[b], pos), true); - ASSERT_EQ(tdm_output_commit(output, 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_layer_set_buffer_with_pos(dst_layer, buffers[b], pos), true); + EXPECT_EQ(tdm_output_commit(output, 0, NULL, NULL), TDM_ERROR_NONE); } void TDMBackendCapture::HideLayer(void) { - ASSERT_NE(output, NULL); - ASSERT_NE(dst_layer, NULL); + EXPECT_NE(output, NULL); + EXPECT_NE(dst_layer, NULL); tdm_layer_unset_buffer(dst_layer); tdm_output_commit(output, 0, NULL, NULL); @@ -409,13 +409,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_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); + EXPECT_EQ(tdm_display_get_capture_available_formats(dpy, &formats, &count), TDM_ERROR_NONE); + EXPECT_TRUE(formats != NULL && formats != (const tbm_format *)TDM_UT_INVALID_VALUE); + EXPECT_TRUE(count > 0 && count != TDM_UT_INVALID_VALUE); } else { - 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); + EXPECT_EQ(tdm_display_get_capture_available_formats(dpy, &formats, &count), TDM_ERROR_NO_CAPABILITY); + EXPECT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE); + EXPECT_EQ(count, TDM_UT_INVALID_VALUE); } } @@ -423,14 +423,14 @@ TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableFormatsNullObject) { const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE; int 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); + EXPECT_EQ(tdm_display_get_capture_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE); + EXPECT_EQ(count, TDM_UT_INVALID_VALUE); } TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableFormatsNullOther) { - ASSERT_EQ(tdm_display_get_capture_available_formats(dpy, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_display_get_capture_available_formats(dpy, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableSize) @@ -441,19 +441,19 @@ TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableSize) int max_h = TDM_UT_INVALID_VALUE; int preferred_align = TDM_UT_INVALID_VALUE; if (has_capture_cap) { - 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); + EXPECT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE); + EXPECT_NE(min_w, TDM_UT_INVALID_VALUE); + EXPECT_NE(min_h, TDM_UT_INVALID_VALUE); + EXPECT_NE(max_w, TDM_UT_INVALID_VALUE); + EXPECT_NE(max_h, TDM_UT_INVALID_VALUE); + EXPECT_NE(preferred_align, TDM_UT_INVALID_VALUE); } else { - 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); + EXPECT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NO_CAPABILITY); + EXPECT_EQ(min_w, TDM_UT_INVALID_VALUE); + EXPECT_EQ(min_h, TDM_UT_INVALID_VALUE); + EXPECT_EQ(max_w, TDM_UT_INVALID_VALUE); + EXPECT_EQ(max_h, TDM_UT_INVALID_VALUE); + EXPECT_EQ(preferred_align, TDM_UT_INVALID_VALUE); } } @@ -464,20 +464,20 @@ 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_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); + EXPECT_EQ(tdm_display_get_capture_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(min_w, TDM_UT_INVALID_VALUE); + EXPECT_EQ(min_h, TDM_UT_INVALID_VALUE); + EXPECT_EQ(max_w, TDM_UT_INVALID_VALUE); + EXPECT_EQ(max_h, TDM_UT_INVALID_VALUE); + EXPECT_EQ(preferred_align, TDM_UT_INVALID_VALUE); } TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableSizeNullOther) { if (has_capture_cap) - ASSERT_EQ(tdm_display_get_capture_available_size(dpy, NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_display_get_capture_available_size(dpy, NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE); else - ASSERT_EQ(tdm_display_get_capture_available_size(dpy, NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NO_CAPABILITY); + EXPECT_EQ(tdm_display_get_capture_available_size(dpy, NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NO_CAPABILITY); } TEST_P(TDMBackendCapture, CaptureDestroy) @@ -485,7 +485,7 @@ TEST_P(TDMBackendCapture, CaptureDestroy) TDM_UT_SKIP_FLAG(has_capture_cap); TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT); - ASSERT_EQ(TestPrepareDefault(), true); + EXPECT_EQ(TestPrepareDefault(), true); TestDone(); } @@ -510,7 +510,7 @@ TEST_P(TDMBackendCapture, CaptureSetInfoNullObject) tdm_info_capture info; memset(&info, 0, sizeof info); - ASSERT_EQ(tdm_capture_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_capture_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendCapture, CaptureSetInfoNullOther) @@ -518,9 +518,9 @@ TEST_P(TDMBackendCapture, CaptureSetInfoNullOther) TDM_UT_SKIP_FLAG(has_capture_cap); TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT); - ASSERT_EQ(TestPrepareDefault(), true); + EXPECT_EQ(TestPrepareDefault(), true); - ASSERT_EQ(tdm_capture_set_info(capture, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_capture_set_info(capture, NULL), TDM_ERROR_INVALID_PARAMETER); TestDone(); } @@ -538,9 +538,9 @@ TEST_P(TDMBackendCapture, CaptureSetDoneHandler) TDM_UT_SKIP_FLAG(has_capture_cap); TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT); - ASSERT_EQ(TestPrepareDefault(), true); + EXPECT_EQ(TestPrepareDefault(), true); - ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, NULL), TDM_ERROR_NONE); TestDone(); } @@ -550,7 +550,7 @@ TEST_P(TDMBackendCapture, CaptureSetDoneHandlerNullObject) TDM_UT_SKIP_FLAG(has_capture_cap); TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT); - ASSERT_EQ(tdm_capture_set_done_handler(NULL, _tc_tdm_capture_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_capture_set_done_handler(NULL, _tc_tdm_capture_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendCapture, CaptureSetDoneHandlerNullOther) @@ -558,9 +558,9 @@ TEST_P(TDMBackendCapture, CaptureSetDoneHandlerNullOther) TDM_UT_SKIP_FLAG(has_capture_cap); TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT); - ASSERT_EQ(TestPrepareDefault(), true); + EXPECT_EQ(TestPrepareDefault(), true); - ASSERT_EQ(tdm_capture_set_done_handler(capture, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_capture_set_done_handler(capture, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); TestDone(); } @@ -581,11 +581,11 @@ TEST_P(TDMBackendCapture, CaptureAttach) else FindLayer(o, formats[f], &dst_pos); - ASSERT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + EXPECT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true); for (int b = 0; b < 3; b++) - ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); TestDone(); } @@ -599,7 +599,7 @@ TEST_P(TDMBackendCapture, CaptureAttachNullObject) tbm_surface_h buffer = (tbm_surface_h)TDM_UT_BUFFER_SIZE; - ASSERT_EQ(tdm_capture_attach(NULL, buffer), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_capture_attach(NULL, buffer), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendCapture, CaptureAttachNullOther) @@ -607,9 +607,9 @@ TEST_P(TDMBackendCapture, CaptureAttachNullOther) TDM_UT_SKIP_FLAG(has_capture_cap); TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT); - ASSERT_EQ(TestPrepareDefault(), true); + EXPECT_EQ(TestPrepareDefault(), true); - ASSERT_EQ(tdm_capture_attach(capture, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_capture_attach(capture, NULL), TDM_ERROR_INVALID_PARAMETER); TestDone(); } @@ -619,9 +619,9 @@ TEST_P(TDMBackendCapture, CaptureCommit) TDM_UT_SKIP_FLAG(has_capture_cap); TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT); - ASSERT_EQ(TestPrepareDefault(), true); + EXPECT_EQ(TestPrepareDefault(), true); - ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); TestDone(); } @@ -631,7 +631,7 @@ TEST_P(TDMBackendCapture, CaptureCommitNullOBject) TDM_UT_SKIP_FLAG(has_capture_cap); TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT); - ASSERT_EQ(tdm_capture_commit(NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_capture_commit(NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendCapture, CaptureCommitDpmsOff) @@ -639,13 +639,13 @@ TEST_P(TDMBackendCapture, CaptureCommitDpmsOff) TDM_UT_SKIP_FLAG(has_capture_cap); TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT); - ASSERT_EQ(TestPrepareDefault(), true); + EXPECT_EQ(TestPrepareDefault(), true); - ASSERT_EQ(tc_tdm_output_unset(dpy, output), true); + EXPECT_EQ(tc_tdm_output_unset(dpy, output), true); - ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); - ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_BAD_REQUEST); + EXPECT_EQ(tdm_capture_commit(capture), TDM_ERROR_BAD_REQUEST); TestDone(); } @@ -670,20 +670,20 @@ TEST_P(TDMBackendCapture, CaptureDestroyWithoutCommit) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); if (tc_tdm_output_is_hwc_enable(outputs[o])) dst_layer = NULL; else FindLayer(o, formats[f], &dst_pos); - ASSERT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + EXPECT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true); - ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) - ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); tdm_capture_destroy(capture); capture = NULL; @@ -704,22 +704,22 @@ TEST_P(TDMBackendCapture, CaptureDestroyBeforeDone) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); if (tc_tdm_output_is_hwc_enable(outputs[o])) dst_layer = NULL; else FindLayer(o, formats[f], &dst_pos); - ASSERT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + EXPECT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true); - ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) - ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); - ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); tdm_capture_destroy(capture); capture = NULL; @@ -742,7 +742,7 @@ TEST_P(TDMBackendCapture, CaptureOneshotLetterboxSize) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); for (int f = 0; f < format_count; f++) { int half_size = ((mode->hdisplay <= mode->vdisplay) ? mode->hdisplay : mode->vdisplay) / 2; @@ -765,19 +765,19 @@ TEST_P(TDMBackendCapture, CaptureOneshotLetterboxSize) } } - ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f], + EXPECT_EQ(TestPrepare(o, half_size, half_size, formats[f], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true); - ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, &done), TDM_ERROR_NONE); retry: for (int b = 0; b < 3; b++) { done = false; - ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); - ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); #if 0 char temp[256]; @@ -815,7 +815,7 @@ TEST_P(TDMBackendCapture, CaptureOneshotFullSize) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); for (int f = 0; f < format_count; f++) { int half_size = ((mode->hdisplay <= mode->vdisplay) ? mode->hdisplay : mode->vdisplay) / 2; @@ -838,19 +838,19 @@ TEST_P(TDMBackendCapture, CaptureOneshotFullSize) } } - ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f], + EXPECT_EQ(TestPrepare(o, half_size, half_size, formats[f], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, true), true); - ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, &done), TDM_ERROR_NONE); retry: for (int b = 0; b < 3; b++) { done = false; - ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); - ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); #if 0 char temp[256]; @@ -888,7 +888,7 @@ TEST_P(TDMBackendCapture, CaptureOneshotAttachFewTimesInOneCommit) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); for (int f = 0; f < format_count; f++) { int half_size = ((mode->hdisplay <= mode->vdisplay) ? mode->hdisplay : mode->vdisplay) / 2; @@ -911,20 +911,20 @@ TEST_P(TDMBackendCapture, CaptureOneshotAttachFewTimesInOneCommit) } } - ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f], + EXPECT_EQ(TestPrepare(o, half_size, half_size, formats[f], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true); done = 0; - ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb2, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb2, &done), TDM_ERROR_NONE); retry: for (int b = 0; b < 3; b++) - ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); - ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); while (done != 3) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) { #if 0 @@ -956,8 +956,8 @@ _tc_tdm_backend_capture_buffer_release_cb(tbm_surface_h buffer, void *user_data) tdm_buffer_remove_release_handler(buffer, _tc_tdm_backend_capture_buffer_release_cb, backend_capture); - ASSERT_EQ(tdm_capture_attach(backend_capture->capture, buffer), TDM_ERROR_NONE); - ASSERT_EQ(tdm_capture_commit(backend_capture->capture), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_attach(backend_capture->capture, buffer), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_commit(backend_capture->capture), TDM_ERROR_NONE); } static void @@ -1000,7 +1000,7 @@ TEST_P(TDMBackendCapture, CaptureStreamLetterboxSize) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); for (int f = 0; f < format_count; f++) { int half_size = ((mode->hdisplay <= mode->vdisplay) ? mode->hdisplay : mode->vdisplay) / 2; @@ -1023,23 +1023,23 @@ TEST_P(TDMBackendCapture, CaptureStreamLetterboxSize) } } - ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f], + EXPECT_EQ(TestPrepare(o, half_size, half_size, formats[f], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_STREAM, -1, false), true); - ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_stream_done_cb, (void*)this), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_stream_done_cb, (void*)this), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) - ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); retry: stream_exit = false; stream_count = 30; - ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); while (!stream_exit) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); TDM_UT_ASK_YNR("* Successed to capture a output to a '%c%c%c%c' buffer as letterbox size and show? (output: %d, layer: %d)", FOURCC_STR(formats[f]), pipe, dst_layer_index); @@ -1064,7 +1064,7 @@ TEST_P(TDMBackendCapture, CaptureStreamFullSize) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); for (int f = 0; f < format_count; f++) { int half_size = ((mode->hdisplay <= mode->vdisplay) ? mode->hdisplay : mode->vdisplay) / 2; @@ -1087,23 +1087,23 @@ TEST_P(TDMBackendCapture, CaptureStreamFullSize) } } - ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f], + EXPECT_EQ(TestPrepare(o, half_size, half_size, formats[f], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_STREAM, -1, true), true); - ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_stream_done_cb, (void*)this), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_stream_done_cb, (void*)this), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) - ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); retry: stream_exit = false; stream_count = 30; - ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); + EXPECT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); while (!stream_exit) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); TDM_UT_ASK_YNR("* Successed to capture a output to a '%c%c%c%c' buffer as full size and show? (output: %d, layer: %d)", FOURCC_STR(formats[f]), pipe, dst_layer_index); diff --git a/haltests/src/tc_tdm_backend_display.cpp b/haltests/src/tc_tdm_backend_display.cpp index b79cbd8..aaff331 100644 --- a/haltests/src/tc_tdm_backend_display.cpp +++ b/haltests/src/tc_tdm_backend_display.cpp @@ -53,21 +53,21 @@ void TDMBackendBasic::SetUp(void) TDMBackendEnv::SetUp(); dpy = tdm_display_init(&ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(dpy, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(dpy, NULL); - ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE); - ASSERT_GE(output_count, 0); + EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE); + EXPECT_GE(output_count, 0); if (output_count > 0) { outputs = (tdm_output**)calloc(output_count, sizeof(tdm_output*)); - ASSERT_NE(outputs, NULL); + EXPECT_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_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); outputs[o] = output; } } @@ -79,17 +79,17 @@ void TDMBackendBasic::SetUp(void) if (tc_tdm_output_is_hwc_enable(outputs[o])) continue; - ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE); - ASSERT_GT(count, 0); + EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE); + EXPECT_GT(count, 0); layer_count += count; layers = (tdm_layer**)realloc(layers, layer_count * sizeof(tdm_layer*)); - ASSERT_NE(layers, NULL); + EXPECT_NE(layers, NULL); for (int l = 0; l < count; l++) { tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret); - ASSERT_NE(layer, NULL); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(layer, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); layers[old_layer_count + l] = layer; } } @@ -110,7 +110,7 @@ void TDMBackendBasic::TearDown(void) DestroyBuffers(); - ASSERT_EQ(tbm_bufmgr_debug_get_ref_count(), 0); + EXPECT_EQ(tbm_bufmgr_debug_get_ref_count(), 0); TDMBackendEnv::TearDown(); } @@ -146,12 +146,12 @@ TEST_P(TDMBackendBasic, VerifyOutputObject) tdm_error ret; int output_count = 0; - ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE); + EXPECT_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_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); TDM_UT_ASSERT_TRUE(output != NULL, "no output. (output: %d). Check display_get_outputs().", o); } } @@ -161,17 +161,17 @@ TEST_P(TDMBackendBasic, VerifyLayerObject) tdm_error ret; int output_count = 0; - ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE); + EXPECT_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_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); if (tc_tdm_output_is_hwc_enable(outputs[o])) TDM_UT_SKIP_FLAG(0); int layer_count = 0; - ASSERT_EQ(tdm_output_get_layer_count(output, &layer_count), TDM_ERROR_NONE); + EXPECT_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); @@ -188,15 +188,15 @@ TEST_P(TDMBackendBasic, VerifyOutputGetProperty) tdm_error ret; int output_count = 0; - ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE); + EXPECT_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_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); const tdm_prop *props = NULL; int prop_count = 0; - ASSERT_EQ(tdm_output_get_available_properties(output, &props, &prop_count), TDM_ERROR_NONE); + EXPECT_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); @@ -204,7 +204,7 @@ TEST_P(TDMBackendBasic, VerifyOutputGetProperty) for (int p = 0; p < prop_count; p++) { tdm_value value; value.s32 = TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_output_get_property(output, props[p].id, &value), TDM_ERROR_NONE); + EXPECT_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); @@ -217,25 +217,25 @@ TEST_P(TDMBackendBasic, VerifyLayerGetProperty) tdm_error ret; int output_count = 0; - ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE); + EXPECT_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_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); if (tc_tdm_output_is_hwc_enable(outputs[o])) TDM_UT_SKIP_FLAG(0); int layer_count = 0; - ASSERT_EQ(tdm_output_get_layer_count(output, &layer_count), TDM_ERROR_NONE); + EXPECT_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_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); const tdm_prop *props = NULL; int prop_count = 0; - ASSERT_EQ(tdm_layer_get_available_properties(layer, &props, &prop_count), TDM_ERROR_NONE); + EXPECT_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); @@ -243,7 +243,7 @@ TEST_P(TDMBackendBasic, VerifyLayerGetProperty) for (int p = 0; p < prop_count; p++) { tdm_value value; value.s32 = TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_layer_get_property(layer, props[p].id, &value), TDM_ERROR_NONE); + EXPECT_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); @@ -264,7 +264,7 @@ TEST_P(TDMBackendBasic, VerifyOutputSetMode) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE); + EXPECT_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."); @@ -276,10 +276,10 @@ TEST_P(TDMBackendBasic, VerifyOutputSetMode) } if (!set_mode && best) set_mode = best; - ASSERT_NE(set_mode, NULL); + EXPECT_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); + EXPECT_EQ(tdm_output_set_mode(outputs[o], set_mode), TDM_ERROR_NONE); + EXPECT_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()"); } } @@ -298,9 +298,9 @@ TEST_P(TDMBackendBasic, VerifyOutputSetDpms) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE); - ASSERT_GT(count, 0); - ASSERT_NE(modes, NULL); + EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE); + EXPECT_GT(count, 0); + EXPECT_NE(modes, NULL); for (int i = 0; i < count; i++) { if (!best) @@ -311,13 +311,13 @@ TEST_P(TDMBackendBasic, VerifyOutputSetDpms) if (!set_mode && best) set_mode = best; - 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); + EXPECT_NE(set_mode, NULL); + EXPECT_EQ(tdm_output_set_mode(outputs[o], set_mode), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_mode(outputs[o], &got_mode), TDM_ERROR_NONE); + EXPECT_EQ(set_mode, got_mode); - 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); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], set_dpms), TDM_ERROR_NONE); + EXPECT_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()"); } } @@ -333,23 +333,23 @@ TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowOneFrame) if (tc_tdm_output_is_hwc_enable(outputs[o])) TDM_UT_SKIP_FLAG(0); - ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); layer = tc_tdm_output_get_primary_layer(outputs[o]); - ASSERT_NE(layer, NULL); + EXPECT_NE(layer, NULL); retry: - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); - ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); + EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_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_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); } } @@ -366,19 +366,19 @@ TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowManyFrames) if (tc_tdm_output_is_hwc_enable(outputs[o])) TDM_UT_SKIP_FLAG(0); - ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); layer = tc_tdm_output_get_primary_layer(outputs[o]); - ASSERT_NE(layer, NULL); + EXPECT_NE(layer, NULL); retry: - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 3, true), true); + EXPECT_EQ(tc_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_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); usleep(40000); /* 40 ms */ next_buffer++; if (next_buffer == 3) @@ -389,8 +389,8 @@ retry: TDM_UT_ASK_YNR("* Successed to display many frames to a primary layer? (output: %d)", o); - ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); } } @@ -415,15 +415,15 @@ TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowOneFrameWithCommitHandler) if (tc_tdm_output_is_hwc_enable(outputs[o])) TDM_UT_SKIP_FLAG(0); - ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); layer = tc_tdm_output_get_primary_layer(outputs[o]); - ASSERT_NE(layer, NULL); + EXPECT_NE(layer, NULL); retry: - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); - ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); + EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); bool done = false; @@ -435,8 +435,8 @@ retry: TDM_UT_ASK_YNR("* Successed to display a frame to a primary layer? (output: %d)", o); - ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); } } @@ -451,17 +451,17 @@ TEST_P(TDMBackendBasic, VerifyOverlayLayersShowOneFrame) if (tc_tdm_output_is_hwc_enable(outputs[o])) TDM_UT_SKIP_FLAG(0); - ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); layer = tc_tdm_output_get_primary_layer(outputs[o]); - ASSERT_NE(layer, NULL); + EXPECT_NE(layer, NULL); - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, false), true); - ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); + EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, false), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); usleep(40000); /* 40 ms */ retry: @@ -470,23 +470,23 @@ retry: if (tdm_layer_get_output(layers[l], &ret) != outputs[o]) continue; - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); if (tc_tdm_layer_is_primary_layer(layers[l])) continue; if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true); - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[0]), true); + EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[0]), true); DestroyBuffers(); } - ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_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_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); } } @@ -501,17 +501,17 @@ TEST_P(TDMBackendBasic, VerifyOverlayLayersShowManyFrames) if (tc_tdm_output_is_hwc_enable(outputs[o])) TDM_UT_SKIP_FLAG(0); - ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); layer = tc_tdm_output_get_primary_layer(outputs[o]); - ASSERT_NE(layer, NULL); + EXPECT_NE(layer, NULL); - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, false), true); - ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); + EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, false), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); usleep(40000); /* 40 ms */ for (int l = 0; l < layer_count; l++) { @@ -520,19 +520,19 @@ TEST_P(TDMBackendBasic, VerifyOverlayLayersShowManyFrames) if (tdm_layer_get_output(layers[l], &ret) != outputs[o]) continue; - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); if (tc_tdm_layer_is_primary_layer(layers[l])) continue; if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; retry: - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); + EXPECT_EQ(tc_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_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); usleep(40000); /* 40 ms */ next_buffer++; if (next_buffer == 3) @@ -543,8 +543,8 @@ retry: TDM_UT_ASK_YNR("* Successed to display many frames to a layer? (output: %d, layer: %d)", o, l); - ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); usleep(40000); /* 40 ms */ } } @@ -572,18 +572,18 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblank) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); if (!tc_tdm_output_is_hwc_enable(outputs[o])) { layer = tc_tdm_output_get_primary_layer(outputs[o]); - ASSERT_NE(layer, NULL); + EXPECT_NE(layer, NULL); - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); - ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); + EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); } /* start from 1 */ @@ -624,18 +624,18 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblankInterval) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); if (!tc_tdm_output_is_hwc_enable(outputs[o])) { layer = tc_tdm_output_get_primary_layer(outputs[o]); - ASSERT_NE(layer, NULL); + EXPECT_NE(layer, NULL); - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); - ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); + EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); } /* start from 1 */ @@ -647,9 +647,9 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblankInterval) done = false; start = tdm_helper_get_time(); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -673,18 +673,18 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblankFewTimesInOneVblank) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); if (!tc_tdm_output_is_hwc_enable(outputs[o])) { layer = tc_tdm_output_get_primary_layer(outputs[o]); - ASSERT_NE(layer, NULL); + EXPECT_NE(layer, NULL); - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); - ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); + EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); } /* start from 1 */ @@ -695,12 +695,12 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblankFewTimesInOneVblank) interval = tc_tdm_output_get_vblank_interval_time(outputs[o]); done1 = done2 = done3 = false; - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done3), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done2), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done3), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done1 || !done2 || !done3) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -760,12 +760,12 @@ TEST_P(TDMBackendBasic, VerifyPPAvaiableSize) int max_w = 0; int max_h = 0; int 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); + EXPECT_EQ(tdm_display_get_pp_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE); + EXPECT_NE(min_w, 0); + EXPECT_NE(min_h, 0); + EXPECT_NE(max_w, 0); + EXPECT_NE(max_h, 0); + EXPECT_NE(preferred_align, 0); } TEST_P(TDMBackendBasic, VerifyPPAvaiableFormats) @@ -795,7 +795,7 @@ TEST_P(TDMBackendBasic, VerifyCaptureObject) tdm_error ret; unsigned int has_capability = 0; - ASSERT_EQ(tdm_output_has_capture_capability(outputs[o], &has_capability), TDM_ERROR_NONE); + EXPECT_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; @@ -824,12 +824,12 @@ TEST_P(TDMBackendBasic, VerifyCaptureAvaiableSize) int max_w = 0; int max_h = 0; int 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); + EXPECT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE); + EXPECT_NE(min_w, 0); + EXPECT_NE(min_h, 0); + EXPECT_NE(max_w, 0); + EXPECT_NE(max_h, 0); + EXPECT_NE(preferred_align, 0); } TEST_P(TDMBackendBasic, VerifyCaptureAvaiableFormats) @@ -876,32 +876,32 @@ TEST_P(TDMBackendDisplay, VerifyPirmaryLayerFormat) TDM_UT_SKIP_FLAG(0); layer = tc_tdm_output_get_primary_layer(outputs[o]); - ASSERT_NE(layer, NULL); + EXPECT_NE(layer, NULL); - 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); + EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE); for (int f = 0; f < format_count; f++) { - ASSERT_EQ(tc_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); + EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); + EXPECT_NE(mode, NULL); retry: TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); - ASSERT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); + EXPECT_EQ(tc_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_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); done = false; - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_EQ(displaying_buffer, buffers[next_buffer]); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(displaying_buffer, buffers[next_buffer]); next_buffer++; if (next_buffer == 3) next_buffer = 0; @@ -916,11 +916,11 @@ retry: TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat) { - ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); + EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); if (output_count > 0) { if (tc_tdm_output_is_hwc_enable(outputs[0])) { - ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true); + EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true); TDM_UT_SKIP_FLAG(0); } } @@ -940,7 +940,7 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat) layer = layers[l]; output = tdm_layer_get_output(layer, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); if (!tc_tdm_output_is_connected(output)) continue; @@ -949,34 +949,34 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat) if (tc_tdm_layer_is_cursor_layer(layer)) continue; - ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l); - 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); + EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); + EXPECT_NE(mode, NULL); - ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE); + EXPECT_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_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); + EXPECT_EQ(tc_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_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); done = false; - ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_EQ(displaying_buffer, buffers[next_buffer]); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(displaying_buffer, buffers[next_buffer]); next_buffer++; if (next_buffer == 3) next_buffer = 0; @@ -987,17 +987,17 @@ retry: DestroyBuffers(); } - ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); } } TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize) { - ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); + EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); if (output_count > 0) { if (tc_tdm_output_is_hwc_enable(outputs[0])) { - ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true); + EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true); TDM_UT_SKIP_FLAG(0); } } @@ -1017,7 +1017,7 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize) layer = layers[l]; output = tdm_layer_get_output(layer, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); if (!tc_tdm_output_is_connected(output)) continue; @@ -1026,17 +1026,17 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize) if (tc_tdm_layer_is_cursor_layer(layer)) continue; - ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l); - 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); + EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); + EXPECT_NE(mode, NULL); - ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE); + EXPECT_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); @@ -1045,19 +1045,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_EQ(tc_tdm_buffer_create(w, h, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); + EXPECT_EQ(tc_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_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); done = false; - ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_EQ(displaying_buffer, buffers[next_buffer]); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(displaying_buffer, buffers[next_buffer]); next_buffer++; if (next_buffer == 3) next_buffer = 0; @@ -1069,17 +1069,17 @@ retry: FOURCC_STR(formats[f]), w, h, pipe, l); } - ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); } } TEST_P(TDMBackendDisplay, VerifyOverlayLayerScale) { - ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); + EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); if (output_count > 0) { if (tc_tdm_output_is_hwc_enable(outputs[0])) { - ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true); + EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true); TDM_UT_SKIP_FLAG(0); } } @@ -1099,9 +1099,9 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerScale) layer = layers[l]; output = tdm_layer_get_output(layer, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); if (!tc_tdm_output_is_connected(output)) continue; @@ -1114,18 +1114,18 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerScale) continue; } - 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); + EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); + EXPECT_NE(mode, NULL); - ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE); + EXPECT_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_EQ(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); + EXPECT_EQ(tc_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); @@ -1141,19 +1141,19 @@ retry: info.dst_pos.w = mode->hdisplay; info.dst_pos.h = mode->vdisplay; info.transform = TDM_TRANSFORM_NORMAL; - ASSERT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE); + EXPECT_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_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE); done = false; - ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_EQ(displaying_buffer, buffers[next_buffer]); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(displaying_buffer, buffers[next_buffer]); next_buffer++; if (next_buffer == 3) next_buffer = 0; @@ -1165,17 +1165,17 @@ retry: FOURCC_STR(formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, pipe, l); } - ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); } } TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition) { - ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); + EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); if (output_count > 0) { if (tc_tdm_output_is_hwc_enable(outputs[0])) { - ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true); + EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true); TDM_UT_SKIP_FLAG(0); } } @@ -1195,7 +1195,7 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition) layer = layers[l]; output = tdm_layer_get_output(layer, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); if (!tc_tdm_output_is_connected(output)) continue; @@ -1204,22 +1204,22 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition) if (tc_tdm_layer_is_cursor_layer(layer)) continue; - ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l); - 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); + EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); + EXPECT_NE(mode, NULL); - ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE); + EXPECT_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_EQ(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); + EXPECT_EQ(tc_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++) { @@ -1239,16 +1239,16 @@ retry: info.dst_pos.w = TDM_UT_BUFFER_SIZE; info.dst_pos.h = TDM_UT_BUFFER_SIZE; info.transform = TDM_TRANSFORM_NORMAL; - ASSERT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE); done = false; - ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_EQ(displaying_buffer, buffers[next_buffer]); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(displaying_buffer, buffers[next_buffer]); next_buffer++; if (next_buffer == 3) next_buffer = 0; @@ -1260,17 +1260,17 @@ retry: FOURCC_STR(formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, pipe, l); } - ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); } } TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop) { - ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); + EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); if (output_count > 0) { if (tc_tdm_output_is_hwc_enable(outputs[0])) { - ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true); + EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true); TDM_UT_SKIP_FLAG(0); } } @@ -1290,9 +1290,9 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop) layer = layers[l]; output = tdm_layer_get_output(layer, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); if (!tc_tdm_output_is_connected(output)) continue; @@ -1307,18 +1307,18 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop) TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l); - 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); + EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); + EXPECT_NE(mode, NULL); - ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE); + EXPECT_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_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); + EXPECT_EQ(tc_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); @@ -1334,19 +1334,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_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE); + EXPECT_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_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE); done = false; - ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_EQ(displaying_buffer, buffers[next_buffer]); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(displaying_buffer, buffers[next_buffer]); next_buffer++; if (next_buffer == 3) next_buffer = 0; @@ -1358,34 +1358,34 @@ retry: FOURCC_STR(formats[f]), pipe, l); } - ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); } } /* should be debugged int emulator kernel */ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOnToOff) { - ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true); + EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true); for (int o = 0; o < output_count; o++) { if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + EXPECT_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_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true); + EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true); for (int o = 0; o < output_count; o++) { if (!tc_tdm_output_is_connected(outputs[o])) continue; - 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); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); } } @@ -1396,8 +1396,8 @@ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOnBeforeSet) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); } } @@ -1408,8 +1408,8 @@ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffBeforeSet) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); } } @@ -1423,14 +1423,14 @@ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithoutComm if (tc_tdm_output_is_hwc_enable(outputs[o])) TDM_UT_SKIP_FLAG(0); - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]); - ASSERT_NE(layer, NULL); + EXPECT_NE(layer, NULL); - ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); } } @@ -1441,20 +1441,20 @@ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithCommit) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); if (tc_tdm_output_is_hwc_enable(outputs[o])) { - ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true); + EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true); TDM_UT_SKIP_FLAG(0); } tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]); - ASSERT_NE(layer, NULL); + EXPECT_NE(layer, NULL); - ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); } } @@ -1464,14 +1464,14 @@ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsAsync) TEST_P(TDMBackendDisplay, VerifyLayerGetInfo) { - ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true); + EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true); for (int o = 0; o < output_count; o++) { if (!tc_tdm_output_is_connected(outputs[o])) continue; if (tc_tdm_output_is_hwc_enable(outputs[o])) { - ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true); + EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true); TDM_UT_SKIP_FLAG(0); } @@ -1479,14 +1479,14 @@ TEST_P(TDMBackendDisplay, VerifyLayerGetInfo) tdm_error ret; tdm_info_layer info, temp; tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]); - ASSERT_NE(layer, NULL); + EXPECT_NE(layer, NULL); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); - ASSERT_NE(displaying_buffer, NULL); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_EQ(tc_tdm_layer_fill_info(layer, displaying_buffer, NULL, &info), true); - ASSERT_EQ(tdm_layer_get_info(layer, &temp), TDM_ERROR_NONE); - ASSERT_EQ(memcmp(&info, &temp, sizeof info), 0); + EXPECT_NE(displaying_buffer, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_layer_fill_info(layer, displaying_buffer, NULL, &info), true); + EXPECT_EQ(tdm_layer_get_info(layer, &temp), TDM_ERROR_NONE); + EXPECT_EQ(memcmp(&info, &temp, sizeof info), 0); } } diff --git a/haltests/src/tc_tdm_backend_pp.cpp b/haltests/src/tc_tdm_backend_pp.cpp index c59a381..c03e3b0 100644 --- a/haltests/src/tc_tdm_backend_pp.cpp +++ b/haltests/src/tc_tdm_backend_pp.cpp @@ -108,29 +108,29 @@ void TDMBackendPP::SetUp(void) if (!tc_tdm_display_has_pp_capability(dpy)) return; - 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); - ASSERT_TRUE(max_h == -1 || max_h > 0); - ASSERT_TRUE(preferred_align == -1 || preferred_align > 0); - ASSERT_EQ(tdm_display_get_pp_preferred_align_vertical(dpy, &preferred_align_vertical), TDM_ERROR_NONE); - ASSERT_TRUE(preferred_align_vertical == -1 || preferred_align_vertical > 0); + EXPECT_EQ(tdm_display_get_pp_capabilities(dpy, &capabilities), TDM_ERROR_NONE); + EXPECT_GT(capabilities, 0); + EXPECT_EQ(tdm_display_get_pp_available_formats(dpy, &formats, &format_count), TDM_ERROR_NONE); + EXPECT_NE(formats, NULL); + EXPECT_GT(format_count, 0); + EXPECT_EQ(tdm_display_get_pp_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE); + EXPECT_TRUE(min_w == -1 || min_w > 0); + EXPECT_TRUE(min_h == -1 || min_h > 0); + EXPECT_TRUE(max_w == -1 || max_w > 0); + EXPECT_TRUE(max_h == -1 || max_h > 0); + EXPECT_TRUE(preferred_align == -1 || preferred_align > 0); + EXPECT_EQ(tdm_display_get_pp_preferred_align_vertical(dpy, &preferred_align_vertical), TDM_ERROR_NONE); + EXPECT_TRUE(preferred_align_vertical == -1 || preferred_align_vertical > 0); for (int o = 0; o < output_count; o++) { if (!tc_tdm_output_is_connected(outputs[o])) continue; output = outputs[o]; - ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); - ASSERT_EQ(tc_tdm_output_prepare(dpy, output, false), true); - ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); - ASSERT_NE(mode, NULL); + EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_output_prepare(dpy, output, false), true); + EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); + EXPECT_NE(mode, NULL); break; } } @@ -141,7 +141,7 @@ void TDMBackendPP::TearDown(void) tdm_pp_destroy(pp); DestroyBuffers(); - ASSERT_EQ(tc_tdm_output_unset(dpy, output), true); + EXPECT_EQ(tc_tdm_output_unset(dpy, output), true); TDMBackendDisplay::TearDown(); } @@ -294,28 +294,28 @@ _tc_tdm_backend_pp_output_commit_cb(tdm_output *output, unsigned int sequence, void TDMBackendPP::ShowBuffer(int b) { - ASSERT_NE(output, NULL); + EXPECT_NE(output, NULL); if (tc_tdm_output_is_hwc_enable(output)) TDM_UT_SKIP_FLAG(0); - ASSERT_NE(dst_layer, NULL); + EXPECT_NE(dst_layer, NULL); bool done = false; - ASSERT_EQ(tc_tdm_layer_set_buffer(dst_layer, dstbuf[b]), true); - ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_pp_output_commit_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_layer_set_buffer(dst_layer, dstbuf[b]), true); + EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_pp_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) { - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } void TDMBackendPP::HideLayer(void) { - ASSERT_NE(output, NULL); + EXPECT_NE(output, NULL); if (tc_tdm_output_is_hwc_enable(output)) TDM_UT_SKIP_FLAG(0); - ASSERT_NE(dst_layer, NULL); + EXPECT_NE(dst_layer, NULL); tdm_layer_unset_buffer(dst_layer); tdm_output_commit(output, 0, NULL, NULL); @@ -403,18 +403,18 @@ TEST_P(TDMBackendPP, PPDispalyGetAvaiableFormatsNullObject) const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; if (tc_tdm_display_has_pp_capability(dpy)) - ASSERT_EQ(tdm_display_get_pp_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_display_get_pp_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER); else - ASSERT_EQ(tdm_display_get_pp_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); + EXPECT_EQ(tdm_display_get_pp_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE); + EXPECT_EQ(count, TDM_UT_INVALID_VALUE); } TEST_P(TDMBackendPP, PPDispalyGetAvaiableFormatsNullOther) { if (tc_tdm_display_has_pp_capability(dpy)) { - ASSERT_EQ(PreparePP(), true); - ASSERT_EQ(tdm_display_get_pp_available_formats(pp, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(PreparePP(), true); + EXPECT_EQ(tdm_display_get_pp_available_formats(pp, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } } @@ -426,29 +426,29 @@ TEST_P(TDMBackendPP, PPDispalyGetAvaiableSizeNullObject) int max_h = TDM_UT_INVALID_VALUE; int preferred_align = TDM_UT_INVALID_VALUE; if (tc_tdm_display_has_pp_capability(dpy)) - ASSERT_EQ(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER); else - ASSERT_EQ(tdm_display_get_pp_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); + EXPECT_EQ(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(min_w, TDM_UT_INVALID_VALUE); + EXPECT_EQ(min_h, TDM_UT_INVALID_VALUE); + EXPECT_EQ(max_w, TDM_UT_INVALID_VALUE); + EXPECT_EQ(max_h, TDM_UT_INVALID_VALUE); + EXPECT_EQ(preferred_align, TDM_UT_INVALID_VALUE); } TEST_P(TDMBackendPP, PPDispalyGetAvaiableSizeNullOther) { if (tc_tdm_display_has_pp_capability(dpy)) { - ASSERT_EQ(PreparePP(), true); - ASSERT_EQ(tdm_display_get_pp_available_size(dpy, NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(PreparePP(), true); + EXPECT_EQ(tdm_display_get_pp_available_size(dpy, NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE); } } TEST_P(TDMBackendPP, PPDispalyGetPreferredAlignVerticalNullObject) { if (tc_tdm_display_has_pp_capability(dpy)) { - ASSERT_EQ(PreparePP(), true); - ASSERT_EQ(tdm_display_get_pp_preferred_align_vertical(NULL, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(PreparePP(), true); + EXPECT_EQ(tdm_display_get_pp_preferred_align_vertical(NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } } @@ -456,7 +456,7 @@ TEST_P(TDMBackendPP, PPDestroy) { TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); - ASSERT_EQ(PreparePP(), true); + EXPECT_EQ(PreparePP(), true); tdm_pp_destroy(pp); pp = NULL; } @@ -479,15 +479,15 @@ TEST_P(TDMBackendPP, PPSetInfoNullObject) tdm_info_pp info; memset(&info, 0, sizeof info); - ASSERT_EQ(tdm_pp_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_pp_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendPP, PPSetInfoNullOther) { TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); - ASSERT_EQ(PreparePP(), true); - ASSERT_EQ(tdm_pp_set_info(pp, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(PreparePP(), true); + EXPECT_EQ(tdm_pp_set_info(pp, NULL), TDM_ERROR_INVALID_PARAMETER); } static void @@ -502,38 +502,38 @@ TEST_P(TDMBackendPP, PPSetDoneHandler) { TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); - ASSERT_EQ(PreparePP(), true); - ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(PreparePP(), true); + EXPECT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, NULL), TDM_ERROR_NONE); } TEST_P(TDMBackendPP, PPSetDoneHandlerNullObject) { TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); - ASSERT_EQ(tdm_pp_set_done_handler(NULL, _tc_tdm_pp_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_pp_set_done_handler(NULL, _tc_tdm_pp_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendPP, PPSetDoneHandlerNullOther) { TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); - ASSERT_EQ(PreparePP(), true); - ASSERT_EQ(tdm_pp_set_done_handler(pp, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(PreparePP(), true); + EXPECT_EQ(tdm_pp_set_done_handler(pp, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendPP, PPAttach) { TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); - ASSERT_EQ(PreparePP(), true); + EXPECT_EQ(PreparePP(), true); for (int f = 0; f < format_count; f++) { - ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + EXPECT_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); for (int b = 0; b < 3; b++) - ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); DestroyBuffers(); } @@ -546,32 +546,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_EQ(tdm_pp_attach(NULL, srcbuf, dstbuf), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_pp_attach(NULL, srcbuf, dstbuf), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendPP, PPAttachNullOther) { TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); - ASSERT_EQ(PreparePP(), true); + EXPECT_EQ(PreparePP(), true); - ASSERT_EQ(tdm_pp_attach(pp, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_pp_attach(pp, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendPP, PPCommit) { TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); - ASSERT_EQ(PreparePP(), true); + EXPECT_EQ(PreparePP(), true); - ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); } TEST_P(TDMBackendPP, PPCommitNullOBject) { TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); - ASSERT_EQ(tdm_pp_commit(NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_pp_commit(NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendPP, PPConvertUnderlay) @@ -581,30 +581,30 @@ TEST_P(TDMBackendPP, PPConvertUnderlay) FindLayerUnderPrimary(); if (!tc_tdm_output_is_hwc_enable(output)) - ASSERT_NE(dst_layer, NULL); + EXPECT_NE(dst_layer, NULL); for (int f = 0; f < dst_format_count; f++) { bool done; TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(dst_formats[f])); - ASSERT_EQ(PreparePP(), true); + EXPECT_EQ(PreparePP(), true); - ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f], + EXPECT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f], TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f], TDM_TRANSFORM_NORMAL), true); - ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE); retry: for (int b = 0; b < 3; b++) { done = false; - ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); - ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); #if 0 char temp[256]; @@ -640,23 +640,23 @@ TEST_P(TDMBackendPP, PPConvertOverlay) TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(dst_formats[f])); - ASSERT_EQ(PreparePP(), true); + EXPECT_EQ(PreparePP(), true); - ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f], + EXPECT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f], TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f], TDM_TRANSFORM_NORMAL), true); - ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE); retry: for (int b = 0; b < 3; b++) { done = false; - ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); - ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); #if 0 char temp[256]; @@ -685,30 +685,30 @@ TEST_P(TDMBackendPP, PPConvertScale) FindLayerUnderPrimary(); if (!tc_tdm_output_is_hwc_enable(output)) - ASSERT_NE(dst_layer, NULL); + EXPECT_NE(dst_layer, NULL); for (int f = 0; f < dst_format_count; f++) { bool done; TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(dst_formats[f])); - ASSERT_EQ(PreparePP(), true); + EXPECT_EQ(PreparePP(), true); - ASSERT_EQ(PrepareBuffers(640, 480, dst_formats[f], + EXPECT_EQ(PrepareBuffers(640, 480, dst_formats[f], mode->hdisplay, mode->vdisplay, dst_formats[f], TDM_TRANSFORM_NORMAL), true); - ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE); retry: for (int b = 0; b < 3; b++) { done = false; - ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); - ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); #if 0 char temp[256]; @@ -738,7 +738,7 @@ TEST_P(TDMBackendPP, PPConvertTransform) FindLayerUnderPrimary(); if (!tc_tdm_output_is_hwc_enable(output)) - ASSERT_NE(dst_layer, NULL); + EXPECT_NE(dst_layer, NULL); for (int f = 0; f < dst_format_count; f++) { for (int t = (int)TDM_TRANSFORM_90; t <= (int)TDM_TRANSFORM_FLIPPED_270; t++) { @@ -746,23 +746,23 @@ TEST_P(TDMBackendPP, PPConvertTransform) TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(dst_formats[f])); - ASSERT_EQ(PreparePP(), true); + EXPECT_EQ(PreparePP(), true); - ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f], + EXPECT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f], TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f], (tdm_transform)t), true); - ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE); retry: for (int b = 0; b < 3; b++) { done = false; - ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); - ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); #if 0 char temp[256]; @@ -793,7 +793,7 @@ TEST_P(TDMBackendPP, PPConvertCSC) FindLayerUnderPrimary(); if (!tc_tdm_output_is_hwc_enable(output)) - ASSERT_NE(dst_layer, NULL); + EXPECT_NE(dst_layer, NULL); for (int df = 0; df < dst_format_count; df++) { for (int sf = 0; sf < format_count; sf++) { @@ -802,23 +802,23 @@ TEST_P(TDMBackendPP, PPConvertCSC) TDM_UT_INFO("* testing for format(%c%c%c%c) -> format(%c%c%c%c)", FOURCC_STR(formats[sf]), FOURCC_STR(dst_formats[df])); - ASSERT_EQ(PreparePP(), true); + EXPECT_EQ(PreparePP(), true); - ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, formats[sf], + EXPECT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, formats[sf], TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[df], TDM_TRANSFORM_NORMAL), true); - ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE); retry: for (int b = 0; b < 3; b++) { done = false; - ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); - ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); #if 0 char temp[256]; @@ -856,25 +856,25 @@ TEST_P(TDMBackendPP, DISABLED_PPAttachFewTimesInOneCommit) { TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); - ASSERT_EQ(PreparePP(), true); + EXPECT_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_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + EXPECT_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); - ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb2, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb2, &done), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) - ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); - ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); while (done != 3) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) ShowBuffer(b); @@ -886,17 +886,17 @@ TEST_P(TDMBackendPP, PPDestroyWithoutCommit) { TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); - ASSERT_EQ(PreparePP(), true); + EXPECT_EQ(PreparePP(), true); int f = 0; - ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + EXPECT_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); - ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb2, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb2, NULL), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) - ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); tdm_pp_destroy(pp); pp = NULL; @@ -908,19 +908,19 @@ TEST_P(TDMBackendPP, PPDestroyBeforeDone) { TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); - ASSERT_EQ(PreparePP(), true); + EXPECT_EQ(PreparePP(), true); int f = 0; - ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + EXPECT_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); - ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb2, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb2, NULL), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) - ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); - ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); + EXPECT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); tdm_pp_destroy(pp); pp = NULL; diff --git a/haltests/src/tc_tdm_buffer.cpp b/haltests/src/tc_tdm_buffer.cpp index c2383e4..6ab4e92 100644 --- a/haltests/src/tc_tdm_buffer.cpp +++ b/haltests/src/tc_tdm_buffer.cpp @@ -51,7 +51,7 @@ void TDMBuffer::SetUp(void) TDMDisplay::SetUp(); buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888); - ASSERT_NE(buffer, NULL); + EXPECT_NE(buffer, NULL); } void TDMBuffer::TearDown(void) @@ -92,13 +92,13 @@ failed: TEST_P(TDMBuffer, BufferRefBackend) { - ASSERT_EQ(tdm_buffer_ref_backend(buffer), buffer); + EXPECT_EQ(tdm_buffer_ref_backend(buffer), buffer); tdm_buffer_unref_backend(buffer); } TEST_P(TDMBuffer, BufferRefBackendNullOBject) { - ASSERT_EQ(tdm_buffer_ref_backend(NULL), NULL); + EXPECT_EQ(tdm_buffer_ref_backend(NULL), NULL); } TEST_P(TDMBuffer, BufferUnrefBackend) @@ -122,46 +122,46 @@ _tc_tdm_buffer_destroy_cb(tbm_surface_h buffer, void *user_data) TEST_P(TDMBuffer, BufferAddDestroyHandler) { bool done = false; - ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE); tbm_surface_destroy(buffer); buffer = NULL; - ASSERT_EQ(done, true); + EXPECT_EQ(done, true); } TEST_P(TDMBuffer, BufferAddDestroyHandlerTwice) { - ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, NULL), TDM_ERROR_NONE); - ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, NULL), TDM_ERROR_BAD_REQUEST); + EXPECT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, NULL), TDM_ERROR_BAD_REQUEST); } TEST_P(TDMBuffer, BufferAddDestroyHandlerNullObject) { - ASSERT_EQ(tdm_buffer_add_destroy_handler(NULL, _tc_tdm_buffer_destroy_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_buffer_add_destroy_handler(NULL, _tc_tdm_buffer_destroy_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBuffer, BufferAddDestroyHandlerNullOther) { - ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_buffer_add_destroy_handler(buffer, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBuffer, BufferRemoveDestroyHandler) { bool done = false; - ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE); tdm_buffer_remove_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, &done); tbm_surface_destroy(buffer); buffer = NULL; - ASSERT_EQ(done, false); + EXPECT_EQ(done, false); } TEST_P(TDMBuffer, BufferRemoveDestroyHandlerDifferentData) { bool done = false; - ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE); tdm_buffer_remove_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, NULL); tbm_surface_destroy(buffer); buffer = NULL; - ASSERT_EQ(done, true); + EXPECT_EQ(done, true); } TEST_P(TDMBuffer, BufferRemoveDestroyHandlerNullObject) @@ -185,51 +185,51 @@ _tc_tdm_buffer_release_cb(tbm_surface_h buffer, void *user_data) TEST_P(TDMBuffer, BufferAddReleaseHandler) { bool done = false; - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); - ASSERT_EQ(done, false); + EXPECT_EQ(done, false); tdm_buffer_unref_backend(buffer); - ASSERT_EQ(done, true); + EXPECT_EQ(done, true); } TEST_P(TDMBuffer, BufferAddReleaseHandlerTwice) { - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, NULL), TDM_ERROR_NONE); - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, NULL), TDM_ERROR_BAD_REQUEST); + EXPECT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, NULL), TDM_ERROR_BAD_REQUEST); } TEST_P(TDMBuffer, BufferAddReleaseHandlerNullObject) { bool done = false; - ASSERT_EQ(tdm_buffer_add_release_handler(NULL, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(done, false); + EXPECT_EQ(tdm_buffer_add_release_handler(NULL, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(done, false); } TEST_P(TDMBuffer, BufferAddReleaseHandlerNullOther) { - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_buffer_add_release_handler(buffer, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBuffer, BufferRemoveReleaseHandler) { bool done = false; - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); - ASSERT_EQ(done, false); + EXPECT_EQ(done, false); tdm_buffer_remove_release_handler(buffer, _tc_tdm_buffer_release_cb, &done); tdm_buffer_unref_backend(buffer); - ASSERT_EQ(done, false); + EXPECT_EQ(done, false); } TEST_P(TDMBuffer, BufferRemoveReleaseHandlerDifferentData) { bool done = false; - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); - ASSERT_EQ(done, false); + EXPECT_EQ(done, false); tdm_buffer_remove_release_handler(buffer, _tc_tdm_buffer_release_cb, NULL); tdm_buffer_unref_backend(buffer); - ASSERT_EQ(done, true); + EXPECT_EQ(done, true); } static void @@ -244,36 +244,36 @@ _tc_tdm_buffer_release_cb2(tbm_surface_h buffer, void *user_data) TEST_P(TDMBuffer, BufferRemoveReleaseHandlerInHandler) { bool done = false; - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); - ASSERT_EQ(done, false); + EXPECT_EQ(done, false); tdm_buffer_unref_backend(buffer); - ASSERT_EQ(done, true); + EXPECT_EQ(done, true); done = false; - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); - ASSERT_EQ(done, false); + EXPECT_EQ(done, false); tdm_buffer_unref_backend(buffer); - ASSERT_EQ(done, true); + EXPECT_EQ(done, true); done = false; - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); - ASSERT_EQ(done, false); + EXPECT_EQ(done, false); tdm_buffer_unref_backend(buffer); - ASSERT_EQ(done, true); + EXPECT_EQ(done, true); } TEST_P(TDMBuffer, BufferRemoveReleaseHandlerNullObject) { bool done = false; - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); - ASSERT_EQ(done, false); + EXPECT_EQ(done, false); tdm_buffer_remove_release_handler(NULL, _tc_tdm_buffer_release_cb, &done); tdm_buffer_unref_backend(buffer); - ASSERT_EQ(done, true); + EXPECT_EQ(done, true); } TEST_P(TDMBuffer, BufferRemoveReleaseHandlerNullOther) diff --git a/haltests/src/tc_tdm_client.cpp b/haltests/src/tc_tdm_client.cpp index d107b20..1856692 100644 --- a/haltests/src/tc_tdm_client.cpp +++ b/haltests/src/tc_tdm_client.cpp @@ -107,7 +107,7 @@ void TDMClient::ServerFork(void) return; server_pid = _tc_tdm_client_server_fork(pipe_parent, pipe_child); - ASSERT_GT(server_pid, 0); + EXPECT_GT(server_pid, 0); } void TDMClient::ServerKill(void) @@ -515,14 +515,14 @@ TEST_P(TDMClient, ClientCreate) tdm_error ret; client = tdm_client_create(&ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(client, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(client, NULL); } TEST_P(TDMClient, ClientCreateNullOther) { client = tdm_client_create(NULL); - ASSERT_NE(client, NULL); + EXPECT_NE(client, NULL); } TEST_P(TDMClient, ClientDestroy) @@ -530,8 +530,8 @@ TEST_P(TDMClient, ClientDestroy) tdm_error ret; client = tdm_client_create(&ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(client, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(client, NULL); tdm_client_destroy(client); client = NULL; @@ -547,24 +547,24 @@ TEST_P(TDMClient, ClientGetFd) { int fd = TDM_UT_INVALID_VALUE; - ASSERT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareClient(), true); - ASSERT_EQ(tdm_client_get_fd(client, &fd), TDM_ERROR_NONE); - ASSERT_GE(fd, 0); + EXPECT_EQ(tdm_client_get_fd(client, &fd), TDM_ERROR_NONE); + EXPECT_GE(fd, 0); } TEST_P(TDMClient, ClientGetFdNullObject) { int fd = TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_client_get_fd(NULL, &fd), TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(fd, TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_client_get_fd(NULL, &fd), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(fd, TDM_UT_INVALID_VALUE); } TEST_P(TDMClient, ClientGetFdNullOther) { - ASSERT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareClient(), true); - ASSERT_EQ(tdm_client_get_fd(client, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_client_get_fd(client, NULL), TDM_ERROR_INVALID_PARAMETER); } static void @@ -580,18 +580,18 @@ TEST_P(TDMClient, ClientHandleEvent) { bool done = false; - ASSERT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareClient(), true); - ASSERT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _tc_tdm_client_vblank_cb, &done), TDM_ERROR_NONE); - ASSERT_EQ(done, false); + EXPECT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _tc_tdm_client_vblank_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(done, false); while (!done) - ASSERT_EQ(tdm_client_handle_events(client), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_handle_events(client), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientHandleEventNullObject) { - ASSERT_EQ(tdm_client_handle_events(NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_client_handle_events(NULL), TDM_ERROR_INVALID_PARAMETER); } /* tdm_client_wait_vblank, deprecated */ @@ -599,13 +599,13 @@ TEST_P(TDMClient, ClientWaitVblank) { bool done = false; - ASSERT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareClient(), true); - ASSERT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _tc_tdm_client_vblank_cb, &done), TDM_ERROR_NONE); - ASSERT_EQ(done, false); + EXPECT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _tc_tdm_client_vblank_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(done, false); while (!done) - ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); } /* tdm_client_get_output */ @@ -613,44 +613,44 @@ TEST_P(TDMClient, ClientGetOutput) { tdm_error ret; - ASSERT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareClient(), true); output = tdm_client_get_output(client, NULL, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); } TEST_P(TDMClient, ClientGetOutputPrimary) { tdm_error ret; - ASSERT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareClient(), true); output = tdm_client_get_output(client, (char*)"primary", &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); } TEST_P(TDMClient, ClientGetOutputDefault) { tdm_error ret; - ASSERT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareClient(), true); output = tdm_client_get_output(client, (char*)"default", &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); } TEST_P(TDMClient, ClientGetOutputInvalidName) { tdm_error ret; - ASSERT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareClient(), true); output = tdm_client_get_output(client, (char*)"invalid", &ret); - ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(output, NULL); } TEST_P(TDMClient, ClientGetOutputNullObject) @@ -658,16 +658,16 @@ TEST_P(TDMClient, ClientGetOutputNullObject) tdm_error ret; output = tdm_client_get_output(NULL, NULL, &ret); - ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(output, NULL); } TEST_P(TDMClient, ClientGetOutputNullOther) { - ASSERT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareClient(), true); output = tdm_client_get_output(client, NULL, NULL); - ASSERT_NE(output, NULL); + EXPECT_NE(output, NULL); } static void @@ -694,54 +694,54 @@ TEST_P(TDMClient, ClientOutputAddChangeHandler) bool done = false; tdm_output_dpms dpms; - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE); - ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); + EXPECT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); while (!done) - ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); - ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); - ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF); + EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); + EXPECT_EQ(dpms, TDM_OUTPUT_DPMS_OFF); - ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); + EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); while (dpms != TDM_OUTPUT_DPMS_ON) { - ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); - ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); } } TEST_P(TDMClient, ClientOutputAddChangeHandlerTwice) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE); - ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_BAD_REQUEST); + EXPECT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_BAD_REQUEST); } TEST_P(TDMClient, ClientOutputAddChangeHandlerNullObject) { - ASSERT_EQ(tdm_client_output_add_change_handler(NULL, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_client_output_add_change_handler(NULL, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMClient, ClientOutputAddChangeHandlerNullOther) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_add_change_handler(output, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_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_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE); tdm_client_output_remove_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL); } @@ -749,10 +749,10 @@ TEST_P(TDMClient, ClientOutputRemoveChangeHandlerDifferentData) { bool done = (bool)TDM_UT_INVALID_VALUE; - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE); tdm_client_output_remove_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL); } @@ -775,20 +775,20 @@ TEST_P(TDMClient, ClientOutputRemoveChangeHandlerInHandler) { tdm_output_dpms dpms = TDM_OUTPUT_DPMS_ON; - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb2, NULL), TDM_ERROR_NONE); - ASSERT_EQ(_tc_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); + EXPECT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb2, NULL), TDM_ERROR_NONE); + EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); + EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); while (dpms != TDM_OUTPUT_DPMS_OFF) { - ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); - ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); } - ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); + EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); while (dpms != TDM_OUTPUT_DPMS_ON) - ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullObject) @@ -798,8 +798,8 @@ TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullObject) TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullOther) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); tdm_client_output_remove_change_handler(output, NULL, NULL); } @@ -809,27 +809,27 @@ TEST_P(TDMClient, ClientOutputGetRefreshRate) { unsigned int refresh = 0; - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_get_refresh_rate(output, &refresh), TDM_ERROR_NONE); - ASSERT_GT(refresh, 0); + EXPECT_EQ(tdm_client_output_get_refresh_rate(output, &refresh), TDM_ERROR_NONE); + EXPECT_GT(refresh, 0); } TEST_P(TDMClient, ClientOutputGetRefreshRateNullObject) { unsigned int 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); + EXPECT_EQ(tdm_client_output_get_refresh_rate(NULL, &refresh), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(refresh, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMClient, ClientOutputGetRefreshRateNullOther) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_get_refresh_rate(output, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_client_output_get_refresh_rate(output, NULL), TDM_ERROR_INVALID_PARAMETER); } /* tdm_client_output_get_mode */ @@ -837,12 +837,12 @@ TEST_P(TDMClient, ClientOutputGetMode) { unsigned int width = 0, height = 0; - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_get_mode(output, &width, &height), TDM_ERROR_NONE); - ASSERT_GT(width, 0); - ASSERT_GT(height, 0); + EXPECT_EQ(tdm_client_output_get_mode(output, &width, &height), TDM_ERROR_NONE); + EXPECT_GT(width, 0); + EXPECT_GT(height, 0); } TEST_P(TDMClient, ClientOutputGetModeNullObject) @@ -850,17 +850,17 @@ TEST_P(TDMClient, ClientOutputGetModeNullObject) unsigned int width = (unsigned int)TDM_UT_INVALID_VALUE; unsigned int height = (unsigned int)TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_client_output_get_mode(NULL, &width, &height), TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(width, (unsigned int)TDM_UT_INVALID_VALUE); - ASSERT_EQ(height, (unsigned int)TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_client_output_get_mode(NULL, &width, &height), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(width, (unsigned int)TDM_UT_INVALID_VALUE); + EXPECT_EQ(height, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMClient, ClientOutputGetModeNullOther) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_get_mode(output, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_client_output_get_mode(output, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } /* tdm_client_output_get_conn_status */ @@ -868,27 +868,27 @@ TEST_P(TDMClient, ClientOutputGetConnStatus) { tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE; - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_get_conn_status(output, &status), TDM_ERROR_NONE); - ASSERT_NE(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_client_output_get_conn_status(output, &status), TDM_ERROR_NONE); + EXPECT_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_EQ(tdm_client_output_get_conn_status(NULL, &status), TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_client_output_get_conn_status(NULL, &status), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE); } TEST_P(TDMClient, ClientOutputGetConnStatusNullOther) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_get_conn_status(output, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_client_output_get_conn_status(output, NULL), TDM_ERROR_INVALID_PARAMETER); } /* tdm_client_output_get_dpms */ @@ -896,27 +896,27 @@ TEST_P(TDMClient, ClientOutputGetDpms) { tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE; - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); - ASSERT_NE(dpms, (tdm_output_dpms)TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); + EXPECT_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_EQ(tdm_client_output_get_dpms(NULL, &dpms), TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(dpms, (tdm_output_dpms)TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_client_output_get_dpms(NULL, &dpms), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(dpms, (tdm_output_dpms)TDM_UT_INVALID_VALUE); } TEST_P(TDMClient, ClientOutputGetDpmsNullOther) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_get_dpms(output, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_client_output_get_dpms(output, NULL), TDM_ERROR_INVALID_PARAMETER); } /* tdm_client_output_create_vblank */ @@ -924,12 +924,12 @@ TEST_P(TDMClient, ClientOutputCreateVblank) { tdm_error ret; - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); vblank = tdm_client_output_create_vblank(output, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(vblank, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(vblank, NULL); } TEST_P(TDMClient, ClientOutputCreateVblankNullObject) @@ -937,17 +937,17 @@ TEST_P(TDMClient, ClientOutputCreateVblankNullObject) tdm_error ret; vblank = tdm_client_output_create_vblank(NULL, &ret); - ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(vblank, NULL); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vblank, NULL); } TEST_P(TDMClient, ClientOutputCreateVblankNullOther) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); vblank = tdm_client_output_create_vblank(output, NULL); - ASSERT_NE(vblank, NULL); + EXPECT_NE(vblank, NULL); } /* tdm_client_vblank_destroy */ @@ -955,12 +955,12 @@ TEST_P(TDMClient, ClientVblankDestroy) { tdm_error ret; - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); vblank = tdm_client_output_create_vblank(output, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(vblank, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(vblank, NULL); tdm_client_vblank_destroy(vblank); vblank = NULL; @@ -974,126 +974,126 @@ TEST_P(TDMClient, ClientVblankDestroyNullObject) /* tdm_client_vblank_set_name */ TEST_P(TDMClient, ClientVblankSetName) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); - ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetNameTwice) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); - 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); + EXPECT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetNameNullObject) { - ASSERT_EQ(tdm_client_vblank_set_name(NULL, TDM_UT_VBLANK_NAME), TDM_ERROR_INVALID_PARAMETER); + EXPECT_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_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); - ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetSyncTwice) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); - ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetSyncNullObject) { - ASSERT_EQ(tdm_client_vblank_set_sync(NULL, 1), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_client_vblank_set_sync(NULL, 1), TDM_ERROR_INVALID_PARAMETER); } /* tdm_client_vblank_set_fps */ TEST_P(TDMClient, ClientVblankSetFps) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); - ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetFpsTwice) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); - ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE); - ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetFpsNullObject) { - ASSERT_EQ(tdm_client_vblank_set_fps(NULL, 30), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_client_vblank_set_fps(NULL, 30), TDM_ERROR_INVALID_PARAMETER); } /* tdm_client_vblank_set_offset */ TEST_P(TDMClient, ClientVblankSetOffset) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); - ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetOffsetTwice) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); - ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE); - ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetOffsetNullObject) { - ASSERT_EQ(tdm_client_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_client_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER); } /* tdm_client_vblank_set_enable_fake */ TEST_P(TDMClient, ClientVblankSetEnableFake) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); - ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetEnableFakeTwice) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); - 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); + EXPECT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankSetEnableFakeNullObject) { - ASSERT_EQ(tdm_client_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_client_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER); } static void @@ -1114,75 +1114,75 @@ TEST_P(TDMClient, ClientVblankWait) { bool done; - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); done = false; - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done) - ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); + EXPECT_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_LT((end - start), (vrefresh_interval + vrefresh_interval)); + EXPECT_LT((end - start), (vrefresh_interval + vrefresh_interval)); } TEST_P(TDMClient, ClientVblankWaitFewTime) { bool done1, done2, done3; - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); done1 = done2 = done3 = false; - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done3), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done2), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done3), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done1 || !done2 || !done3) - ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); + EXPECT_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_LT((end - start), (vrefresh_interval + vrefresh_interval)); + EXPECT_LT((end - start), (vrefresh_interval + vrefresh_interval)); } TEST_P(TDMClient, ClientVblankWaitInterval0) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); - ASSERT_EQ(tdm_client_vblank_wait(vblank, 0, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_client_vblank_wait(vblank, 0, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMClient, ClientVblankWaitInterval) { bool done; - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); /* start from 1 */ for (int t = 1; t < 10; t++) { done = false; - ASSERT_EQ(tdm_client_vblank_wait(vblank, t, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_wait(vblank, t, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done) - ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); + EXPECT_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_GT((end - start), (vrefresh_interval * (t - 1))); - ASSERT_LT((end - start), (vrefresh_interval * t + vrefresh_interval)); + EXPECT_GT((end - start), (vrefresh_interval * (t - 1))); + EXPECT_LT((end - start), (vrefresh_interval * t + vrefresh_interval)); } } @@ -1201,51 +1201,51 @@ _tc_tdm_client_vblank_cb3(tdm_client_vblank *vblank, TEST_P(TDMClient, ClientVblankWaitSeq) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); for (int t = 0; t < 10; t++) { unsigned int cur_seq = 0, temp = 0; - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); start = tdm_helper_get_time(); - ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + 1, _tc_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + 1, _tc_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE); while (temp == 0) - ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); + EXPECT_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_LT((end - start), (vrefresh_interval + vrefresh_interval)); + EXPECT_LT((end - start), (vrefresh_interval + vrefresh_interval)); } } TEST_P(TDMClient, ClientVblankWaitSeqInterval) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); /* start from 1 */ for (int t = 1; t < 10; t++) { unsigned int cur_seq = 0, temp = 0; - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); start = tdm_helper_get_time(); - ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + t, _tc_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + t, _tc_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE); while (temp == 0) - ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); + EXPECT_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_GT((end - start), (vrefresh_interval * (t - 1))); - ASSERT_LT((end - start), (vrefresh_interval * t + vrefresh_interval)); + EXPECT_GT((end - start), (vrefresh_interval * (t - 1))); + EXPECT_LT((end - start), (vrefresh_interval * t + vrefresh_interval)); } } @@ -1253,23 +1253,23 @@ TEST_P(TDMClient, ClientVblankWaitSetOffset) { bool done; - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); - ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 100), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_set_offset(vblank, 100), TDM_ERROR_NONE); done = false; - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done) - ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); + EXPECT_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_GT((end - start), (0.1)); - ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval + 0.1)); + EXPECT_GT((end - start), (0.1)); + EXPECT_LT((end - start), (vrefresh_interval + vrefresh_interval + 0.1)); } TEST_P(TDMClient, ClientVblankWaitSetFps) @@ -1278,24 +1278,24 @@ TEST_P(TDMClient, ClientVblankWaitSetFps) double interval; unsigned int fps = 10; - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); - ASSERT_EQ(tdm_client_vblank_set_fps(vblank, fps), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_set_fps(vblank, fps), TDM_ERROR_NONE); interval = 1.0 / (double)fps; done = false; - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done) - ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); + EXPECT_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_GT((end - start), (interval - vrefresh_interval * 2)); - ASSERT_LT((end - start), (interval + vrefresh_interval)); + EXPECT_GT((end - start), (interval - vrefresh_interval * 2)); + EXPECT_LT((end - start), (interval + vrefresh_interval)); } #if 0 @@ -1310,16 +1310,16 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps) unsigned int global_fps = 5; double start, end, interval; - ASSERT_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks3(), true); - ASSERT_EQ(vblank_count, 3); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_EQ(TestCreateVblanks3(), true); + EXPECT_EQ(vblank_count, 3); - ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE); - ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE); + EXPECT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE); vrefresh_interval = 1.0 / (double)fps; for (int v = 0; v < 3; v++) - ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)), TDM_ERROR_NONE); /* enable test */ tdm_vblank_enable_global_fps(1, global_fps); @@ -1327,37 +1327,37 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps) for (int v = 0; v < 3; v++) { cur_seq[v] = 0; - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); } start = tdm_helper_get_time(); while (cur_seq[0] == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); - ASSERT_NE(cur_seq[1], 0); - ASSERT_NE(cur_seq[2], 0); + EXPECT_NE(cur_seq[1], 0); + EXPECT_NE(cur_seq[2], 0); /* "+- vrefresh_interval" consider the delay of socket communication between kernel and platform */ - ASSERT_GT((end - start), (interval - vrefresh_interval)); - ASSERT_LT((end - start), (interval + vrefresh_interval)); + EXPECT_GT((end - start), (interval - vrefresh_interval)); + EXPECT_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_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); } while (cur_seq[0] == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); - ASSERT_EQ(cur_seq[1], 0); - ASSERT_EQ(cur_seq[2], 0); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(cur_seq[1], 0); + EXPECT_EQ(cur_seq[2], 0); while (cur_seq[1] == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); - ASSERT_EQ(cur_seq[2], 0); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(cur_seq[2], 0); } TEST_P(TDMVblank, VblankWaitIgnoreGlobalFps) @@ -1369,38 +1369,38 @@ TEST_P(TDMVblank, VblankWaitIgnoreGlobalFps) unsigned int global_fps = 5; double start, end, interval; - ASSERT_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks3(), true); - ASSERT_EQ(vblank_count, 3); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_EQ(TestCreateVblanks3(), true); + EXPECT_EQ(vblank_count, 3); - ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE); - ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE); + EXPECT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE); interval = 1.0 / (double)fps; /* 2nd vblank will ignore the global fps. */ - ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[1], 1), TDM_ERROR_NONE); + EXPECT_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_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); } start = tdm_helper_get_time(); while (cur_seq[1] == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); - ASSERT_EQ(cur_seq[0], 0); - ASSERT_EQ(cur_seq[2], 0); + EXPECT_EQ(cur_seq[0], 0); + EXPECT_EQ(cur_seq[2], 0); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ - ASSERT_LT((end - start), (interval + interval)); + EXPECT_LT((end - start), (interval + interval)); while (cur_seq[0] == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); - ASSERT_NE(cur_seq[2], 0); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_NE(cur_seq[2], 0); } #endif @@ -1409,36 +1409,36 @@ TEST_P(TDMClient, ClientVblankWaitNullObject) { unsigned int cur_seq = 0; - ASSERT_EQ(tdm_client_vblank_wait(NULL, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_client_vblank_wait(NULL, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMClient, ClientVblankWaitNullOther) { - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_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_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); - ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); + EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); while (dpms != TDM_OUTPUT_DPMS_OFF) - ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); - ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF); + EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); + EXPECT_EQ(dpms, TDM_OUTPUT_DPMS_OFF); - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_DPMS_OFF); + EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_DPMS_OFF); - ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); + EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); while (dpms != TDM_OUTPUT_DPMS_ON) - ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientVblankWaitSetEnableFakeDpmsOff) @@ -1446,25 +1446,25 @@ TEST_P(TDMClient, ClientVblankWaitSetEnableFakeDpmsOff) tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE; bool done; - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); - ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); + EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); while (dpms != TDM_OUTPUT_DPMS_OFF) - ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); - ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE); done = false; - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); - ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); + EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); while (dpms != TDM_OUTPUT_DPMS_ON) - ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); } /* tdm_client_vblank_wait */ @@ -1473,33 +1473,33 @@ TEST_P(TDMClient, ClientVblankIsWaiting) bool done; unsigned int waiting; - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); + EXPECT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareOutput(), true); + EXPECT_EQ(PrepareVblank(), true); done = false; - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); waiting = tdm_client_vblank_is_waiting(vblank); - ASSERT_EQ(waiting, 1); + EXPECT_EQ(waiting, 1); start = tdm_helper_get_time(); while (!done) - ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); + EXPECT_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_LT((end - start), (vrefresh_interval + vrefresh_interval)); + EXPECT_LT((end - start), (vrefresh_interval + vrefresh_interval)); waiting = tdm_client_vblank_is_waiting(vblank); - ASSERT_EQ(waiting, 0); + EXPECT_EQ(waiting, 0); } /* tdm_client_vblank_wait */ TEST_P(TDMClient, ClientVblankIsWaitingNullObject) { unsigned int waiting = tdm_client_vblank_is_waiting(NULL); - ASSERT_EQ(waiting, 0); + EXPECT_EQ(waiting, 0); } TEST_P(TDMClient, ClientCreateVOutput) @@ -1510,15 +1510,15 @@ TEST_P(TDMClient, ClientCreateVOutput) virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0); if (virtual_conf == 0) { - ASSERT_EQ(virtual_conf, 0); + EXPECT_EQ(virtual_conf, 0); return; } - ASSERT_EQ(PrepareClient(), true); + EXPECT_EQ(PrepareClient(), true); voutput = tdm_client_create_voutput(client, name, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(voutput, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(voutput, NULL); tdm_client_voutput_destroy(voutput); } @@ -1591,7 +1591,7 @@ void TDMVirtualOutput::ServerFork(void) return; server_pid = _tc_tdm_client_server_fork(pipe_parent, pipe_child); - ASSERT_GT(server_pid, 0); + EXPECT_GT(server_pid, 0); } void TDMVirtualOutput::SetUpTestCase(void) @@ -1602,7 +1602,7 @@ void TDMVirtualOutput::SetUpTestCase(void) if (server_pid == -1) ServerFork(); - ASSERT_EQ(PrepareVOutput(), true); + EXPECT_EQ(PrepareVOutput(), true); } void TDMVirtualOutput::TearDownTestCase(void) @@ -1676,13 +1676,13 @@ TEST_F(TDMVirtualOutput, SetAvailableModes) if (this->voutput == NULL) { virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0); - ASSERT_EQ(virtual_conf, 0); + EXPECT_EQ(virtual_conf, 0); return; } _tc_tdm_client_virutual_make_available_mode(modes, count); ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); } TEST_F(TDMVirtualOutput, FailTestSetAvailableModes) @@ -1694,15 +1694,15 @@ TEST_F(TDMVirtualOutput, FailTestSetAvailableModes) if (this->voutput == NULL) { virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0); - ASSERT_EQ(virtual_conf, 0); + EXPECT_EQ(virtual_conf, 0); return; } ret = tdm_client_voutput_set_available_modes(NULL, modes, count); - ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); ret = tdm_client_voutput_set_available_modes(this->voutput, NULL, count); - ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); } TEST_F(TDMVirtualOutput, SetPhysicalSize) @@ -1713,12 +1713,12 @@ TEST_F(TDMVirtualOutput, SetPhysicalSize) if (this->voutput == NULL) { virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0); - ASSERT_EQ(virtual_conf, 0); + EXPECT_EQ(virtual_conf, 0); return; } ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); } TEST_F(TDMVirtualOutput, FailTestSetPhysicalSize) @@ -1729,12 +1729,12 @@ TEST_F(TDMVirtualOutput, FailTestSetPhysicalSize) if (this->voutput == NULL) { virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0); - ASSERT_EQ(virtual_conf, 0); + EXPECT_EQ(virtual_conf, 0); return; } ret = tdm_client_voutput_set_physical_size(this->voutput, invalid_mmWidth, invalid_mmHeight); - ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); } static void @@ -1753,15 +1753,15 @@ TEST_F(TDMVirtualOutput, AddCommitHandler) if (this->voutput == NULL) { virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0); - ASSERT_EQ(virtual_conf, 0); + EXPECT_EQ(virtual_conf, 0); return; } ret = tdm_client_voutput_add_commit_handler(this->voutput, _tc_tdm_client_voutput_commit_handler, &flag_callback_called); - ASSERT_EQ(ret, TDM_ERROR_NONE); -// ASSERT_EQ(flag_callback_called, 1); + EXPECT_EQ(ret, TDM_ERROR_NONE); +// EXPECT_EQ(flag_callback_called, 1); tdm_client_voutput_remove_commit_handler(this->voutput, _tc_tdm_client_voutput_commit_handler, @@ -1775,12 +1775,12 @@ TEST_F(TDMVirtualOutput, CommitDone) if (this->voutput == NULL) { virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0); - ASSERT_EQ(virtual_conf, 0); + EXPECT_EQ(virtual_conf, 0); return; } ret = tdm_client_voutput_commit_done(this->voutput); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); } TEST_F(TDMVirtualOutput, GetClientOutput) @@ -1791,13 +1791,13 @@ TEST_F(TDMVirtualOutput, GetClientOutput) if (this->voutput == NULL) { virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0); - ASSERT_EQ(virtual_conf, 0); + EXPECT_EQ(virtual_conf, 0); return; } output = tdm_client_voutput_get_client_output(this->voutput, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); } static void @@ -1858,38 +1858,38 @@ TEST_F(TDMVirtualOutput, ConnectDisconnect) if (this->voutput == NULL) { virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0); - ASSERT_EQ(virtual_conf, 0); + EXPECT_EQ(virtual_conf, 0); return; } output = tdm_client_voutput_get_client_output(this->voutput, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); ret = tdm_client_output_add_change_handler(output, _tc_voutput_output_handler_cb, &done); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); ret = tdm_client_output_add_change_handler(output, _tc_voutput_output_handler_cb2, &done2); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); _tc_tdm_client_virutual_make_available_mode(modes, count); ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); ret = tdm_client_voutput_connect(this->voutput); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); while (!done) - ASSERT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE); ret = tdm_client_voutput_disconnect(this->voutput); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); while (!done2) - ASSERT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE); tdm_client_output_remove_change_handler(output, _tc_voutput_output_handler_cb, &done); tdm_client_output_remove_change_handler(output, _tc_voutput_output_handler_cb2, &done2); @@ -1909,44 +1909,44 @@ TEST_F(TDMVirtualOutput, SetMode) if (this->voutput == NULL) { virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0); - ASSERT_EQ(virtual_conf, 0); + EXPECT_EQ(virtual_conf, 0); return; } output = tdm_client_voutput_get_client_output(this->voutput, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); ret = tdm_client_output_add_change_handler(output, _tc_voutput_output_handler_cb, &done); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); ret = tdm_client_output_add_change_handler(output, _tc_voutput_output_handler_cb2, &done2); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); ret = tdm_client_output_add_change_handler(output, _tc_voutput_output_handler_cb3, &done3); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); _tc_tdm_client_virutual_make_available_mode(modes, count); ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); ret = tdm_client_voutput_connect(this->voutput); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); while (!done) - ASSERT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE); - ASSERT_EQ(tdm_client_voutput_set_mode(this->voutput, count - 1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_voutput_set_mode(this->voutput, count - 1), TDM_ERROR_NONE); while (!done3) - ASSERT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE); ret = tdm_client_voutput_disconnect(this->voutput); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); while (!done2) - ASSERT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE); + EXPECT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE); tdm_client_output_remove_change_handler(output, _tc_voutput_output_handler_cb, &done); tdm_client_output_remove_change_handler(output, _tc_voutput_output_handler_cb2, &done2); @@ -1963,26 +1963,26 @@ TEST_F(TDMVirtualOutput, SetModeNullObject) if (this->voutput == NULL) { virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0); - ASSERT_EQ(virtual_conf, 0); + EXPECT_EQ(virtual_conf, 0); return; } ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); _tc_tdm_client_virutual_make_available_mode(modes, count); ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); ret = tdm_client_voutput_connect(this->voutput); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); tdm_client_handle_events_timeout(this->client, 50); - ASSERT_EQ(tdm_client_voutput_set_mode(NULL, 0), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_client_voutput_set_mode(NULL, 0), TDM_ERROR_INVALID_PARAMETER); ret = tdm_client_voutput_disconnect(this->voutput); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); tdm_client_handle_events_timeout(this->client, 0); } @@ -1997,26 +1997,26 @@ TEST_F(TDMVirtualOutput, SetModeInvalidIndex) if (this->voutput == NULL) { virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0); - ASSERT_EQ(virtual_conf, 0); + EXPECT_EQ(virtual_conf, 0); return; } ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); _tc_tdm_client_virutual_make_available_mode(modes, count); ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); ret = tdm_client_voutput_connect(this->voutput); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); tdm_client_handle_events_timeout(this->client, 50); - ASSERT_EQ(tdm_client_voutput_set_mode(this->voutput, -1), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_client_voutput_set_mode(this->voutput, -1), TDM_ERROR_INVALID_PARAMETER); ret = tdm_client_voutput_disconnect(this->voutput); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); tdm_client_handle_events_timeout(this->client, 0); } diff --git a/haltests/src/tc_tdm_display.cpp b/haltests/src/tc_tdm_display.cpp index 9ec8ff3..80e49d8 100644 --- a/haltests/src/tc_tdm_display.cpp +++ b/haltests/src/tc_tdm_display.cpp @@ -49,16 +49,16 @@ void TDMDisplay::SetUp(void) TDMEnv::SetUp(); dpy = tdm_display_init(&ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(dpy, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(dpy, NULL); bufmgr = tbm_bufmgr_init(-1); - ASSERT_NE(bufmgr, NULL); + EXPECT_NE(bufmgr, NULL); - ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); - ASSERT_GT(count, 0); + EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); + EXPECT_GT(count, 0); - ASSERT_EQ(tdm_display_get_capabilities(dpy, &capabilities), TDM_ERROR_NONE); + EXPECT_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; } @@ -68,7 +68,7 @@ void TDMDisplay::TearDown(void) tbm_bufmgr_deinit(bufmgr); tdm_display_deinit(dpy); - ASSERT_EQ(tbm_bufmgr_debug_get_ref_count(), 0); + EXPECT_EQ(tbm_bufmgr_debug_get_ref_count(), 0); TDMEnv::TearDown(); } @@ -118,38 +118,38 @@ tc_tdm_display_has_capture_capability(tdm_display *dpy) TEST_P(TDMDisplay, DisplayUpdate) { - ASSERT_EQ(tdm_display_update(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tdm_display_update(dpy), TDM_ERROR_NONE); } TEST_P(TDMDisplay, DisplayUpdateNullObject) { - ASSERT_EQ(tdm_display_update(NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_display_update(NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMDisplay, DisplayGetFDSuccesful) { int fd = TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_display_get_fd(dpy, &fd), TDM_ERROR_NONE); - ASSERT_NE(fd, TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_display_get_fd(dpy, &fd), TDM_ERROR_NONE); + EXPECT_NE(fd, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetFDNullObject) { int fd = TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_display_get_fd(NULL, &fd), TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(fd, TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_display_get_fd(NULL, &fd), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(fd, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetFDNullFD) { - ASSERT_EQ(tdm_display_get_fd(dpy, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_display_get_fd(dpy, NULL), TDM_ERROR_INVALID_PARAMETER); } /* DISABLED */ TEST_P(TDMDisplay, DISABLED_DisplayHandleEvents) { /* TODO Generate events*/ - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } TEST_P(TDMDisplay, DisplayFlush) @@ -168,11 +168,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_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); + EXPECT_EQ(tdm_display_get_backend_info(dpy, &name, &vendor, &major, &minor), TDM_ERROR_NONE); + EXPECT_NE(name, (const char*)TDM_UT_INVALID_VALUE); + EXPECT_NE(vendor, (const char*)TDM_UT_INVALID_VALUE); + EXPECT_NE(major, TDM_UT_INVALID_VALUE); + EXPECT_NE(minor, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetBackendInfoNullObject) @@ -181,35 +181,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_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); + EXPECT_EQ(tdm_display_get_backend_info(NULL, &name, &vendor, &major, &minor), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(name, (const char*)TDM_UT_INVALID_VALUE); + EXPECT_EQ(vendor, (const char*)TDM_UT_INVALID_VALUE); + EXPECT_EQ(major, TDM_UT_INVALID_VALUE); + EXPECT_EQ(minor, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetBackendInfoNullOther) { - ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, NULL, NULL), TDM_ERROR_NONE); + EXPECT_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_EQ(tdm_display_get_capabilities(dpy, &capabilities), TDM_ERROR_NONE); - ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_display_get_capabilities(dpy, &capabilities), TDM_ERROR_NONE); + EXPECT_NE(capabilities, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetCapabilitiesNullObject) { tdm_display_capability 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); + EXPECT_EQ(tdm_display_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(capabilities, (tdm_display_capability)TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetCapabilitiesNullOther) { - ASSERT_EQ(tdm_display_get_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_display_get_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMDisplay, DisplayGetPPCapabilities) @@ -219,22 +219,22 @@ TEST_P(TDMDisplay, DisplayGetPPCapabilities) if (!has_pp_cap) return; ret = tdm_display_get_pp_capabilities(dpy, &capabilities); - ASSERT_TRUE(ret == TDM_ERROR_NONE || ret == TDM_ERROR_NO_CAPABILITY); + EXPECT_TRUE(ret == TDM_ERROR_NONE || ret == TDM_ERROR_NO_CAPABILITY); if (ret == TDM_ERROR_NONE) - ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE); + EXPECT_NE(capabilities, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetPPCapabilitiesNullObject) { tdm_pp_capability 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); + EXPECT_EQ(tdm_display_get_pp_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(capabilities, (tdm_pp_capability)TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetPPCapabilitiesNullOther) { - ASSERT_EQ(tdm_display_get_pp_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_display_get_pp_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMDisplay, DisplayGetCaptureCapabilities) @@ -246,60 +246,60 @@ TEST_P(TDMDisplay, DisplayGetCaptureCapabilities) return; ret = tdm_display_get_capture_capabilities(dpy, &capabilities); - ASSERT_TRUE(ret == TDM_ERROR_NONE || ret == TDM_ERROR_NO_CAPABILITY); + EXPECT_TRUE(ret == TDM_ERROR_NONE || ret == TDM_ERROR_NO_CAPABILITY); if (ret == TDM_ERROR_NONE) - ASSERT_NE(capabilities, (tdm_capture_capability)TDM_UT_INVALID_VALUE); + EXPECT_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_EQ(tdm_display_get_capture_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(capabilities, (tdm_capture_capability)TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_display_get_capture_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(capabilities, (tdm_capture_capability)TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetCaptureCapabilitiesNullOther) { - ASSERT_EQ(tdm_display_get_capture_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_display_get_capture_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMDisplay, DisplayGetMaxLayerCount) { int 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); + EXPECT_EQ(tdm_display_get_max_layer_count(dpy, &max_count), TDM_ERROR_NONE); + EXPECT_NE(max_count, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetMaxLayerCountNullObject) { int 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); + EXPECT_EQ(tdm_display_get_max_layer_count(NULL, &max_count), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(max_count, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetMaxLayerCountNullOther) { - ASSERT_EQ(tdm_display_get_max_layer_count(dpy, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_display_get_max_layer_count(dpy, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMDisplay, DisplayGetOutputCount) { int count = TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); - ASSERT_NE(count, TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); + EXPECT_NE(count, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetOutputCountNullObject) { int 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); + EXPECT_EQ(tdm_display_get_output_count(NULL, &count), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(count, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, DisplayGetOutputCountNullOther) { - ASSERT_EQ(tdm_display_get_output_count(dpy, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_display_get_output_count(dpy, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMDisplay, DisplayGetOutput) @@ -308,13 +308,13 @@ TEST_P(TDMDisplay, DisplayGetOutput) int o, count = TDM_UT_INVALID_VALUE; tdm_error ret; - ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); - ASSERT_GT(count, 0); + EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); + EXPECT_GT(count, 0); for (o = 0; o < count; o++) { output = tdm_display_get_output(dpy, o, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); } } @@ -323,12 +323,12 @@ TEST_P(TDMDisplay, DisplayGetOutputNullAll) tdm_output *output; int o, count = TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); - ASSERT_GT(count, 0); + EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); + EXPECT_GT(count, 0); for (o = 0; o < count; o++) { output = tdm_display_get_output(NULL, o, NULL); - ASSERT_EQ(output, NULL); + EXPECT_EQ(output, NULL); } } @@ -338,8 +338,8 @@ TEST_P(TDMDisplay, DisplayGetOutputNullObject) tdm_error ret; output = tdm_display_get_output(NULL, 0, &ret); - ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(output, NULL); } TEST_P(TDMDisplay, DisplayGetOutputNullOther) @@ -347,12 +347,12 @@ TEST_P(TDMDisplay, DisplayGetOutputNullOther) tdm_output *output; int o, count = TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); - ASSERT_GT(count, 0); + EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); + EXPECT_GT(count, 0); for (o = 0; o < count; o++) { output = tdm_display_get_output(dpy, o, NULL); - ASSERT_NE(output, NULL); + EXPECT_NE(output, NULL); } } @@ -362,12 +362,12 @@ TEST_P(TDMDisplay, DisplayGetOutputWrongIndex) tdm_error ret; output = tdm_display_get_output(dpy, -1, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_EQ(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(output, NULL); output = tdm_display_get_output(dpy, INT_MAX, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_EQ(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(output, NULL); } TEST_P(TDMDisplay, DisplayFindOutput) @@ -376,16 +376,16 @@ TEST_P(TDMDisplay, DisplayFindOutput) int count = TDM_UT_INVALID_VALUE; tdm_error ret; - ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); - ASSERT_GT(count, 0); + EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); + EXPECT_GT(count, 0); output = tdm_display_find_output(dpy, "primary", &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); output = tdm_display_find_output(dpy, "invalid", &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_EQ(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(output, NULL); } TEST_P(TDMDisplay, DisplayCreatePp) @@ -397,8 +397,8 @@ TEST_P(TDMDisplay, DisplayCreatePp) return; pp = tdm_display_create_pp(dpy, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(pp, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(pp, NULL); tdm_pp_destroy(pp); } @@ -412,8 +412,8 @@ TEST_P(TDMDisplay, DisplayCreatePpNullObject) return; pp = tdm_display_create_pp(NULL, &ret); - ASSERT_NE(ret, TDM_ERROR_NONE); - ASSERT_EQ(pp, NULL); + EXPECT_NE(ret, TDM_ERROR_NONE); + EXPECT_EQ(pp, NULL); } TEST_P(TDMDisplay, ModuleGetInfo) @@ -422,8 +422,8 @@ TEST_P(TDMDisplay, ModuleGetInfo) int o, count = TDM_UT_INVALID_VALUE; tdm_error ret; - ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); - ASSERT_GT(count, 0); + EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); + EXPECT_GT(count, 0); for (o = 0; o < count; o++) { tdm_module *module; @@ -433,18 +433,18 @@ TEST_P(TDMDisplay, ModuleGetInfo) int minor = TDM_UT_INVALID_VALUE; output = tdm_display_get_output(dpy, o, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); module = tdm_output_get_backend_module(output, &ret); - 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); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(module, NULL); + + EXPECT_EQ(tdm_module_get_info(module, &name, &vendor, &major, &minor), TDM_ERROR_NONE); + EXPECT_NE(name, (const char *)TDM_UT_INVALID_VALUE); + EXPECT_NE(vendor, (const char *)TDM_UT_INVALID_VALUE); + EXPECT_NE(major, TDM_UT_INVALID_VALUE); + EXPECT_NE(minor, TDM_UT_INVALID_VALUE); } } @@ -455,11 +455,11 @@ TEST_P(TDMDisplay, ModuleGetInfoNullObject) int major = TDM_UT_INVALID_VALUE; int 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); + EXPECT_EQ(tdm_module_get_info(NULL, &name, &vendor, &major, &minor), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(name, (const char *)TDM_UT_INVALID_VALUE); + EXPECT_EQ(vendor, (const char *)TDM_UT_INVALID_VALUE); + EXPECT_EQ(major, TDM_UT_INVALID_VALUE); + EXPECT_EQ(minor, TDM_UT_INVALID_VALUE); } TEST_P(TDMDisplay, ModuleGetInfoNullOther) @@ -468,21 +468,21 @@ TEST_P(TDMDisplay, ModuleGetInfoNullOther) int o, count = TDM_UT_INVALID_VALUE; tdm_error ret; - ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); - ASSERT_GT(count, 0); + EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE); + EXPECT_GT(count, 0); for (o = 0; o < count; o++) { tdm_module *module; output = tdm_display_get_output(dpy, o, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); module = tdm_output_get_backend_module(output, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(module, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(module, NULL); - ASSERT_EQ(tdm_module_get_info(module, NULL, NULL, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_module_get_info(module, NULL, NULL, NULL, NULL), TDM_ERROR_NONE); } } diff --git a/haltests/src/tc_tdm_env.cpp b/haltests/src/tc_tdm_env.cpp index 398e627..30b73ea 100644 --- a/haltests/src/tc_tdm_env.cpp +++ b/haltests/src/tc_tdm_env.cpp @@ -82,8 +82,8 @@ TEST_P(TDMEnv, DisplayInitDeinit) tdm_error ret; dpy = tdm_display_init(&ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(dpy, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(dpy, NULL); tdm_display_deinit(dpy); } @@ -96,8 +96,8 @@ TEST_P(TDMEnv, DisplayInitDeinitWithoutEnv) TDMEnv::TearDown(); dpy = tdm_display_init(&ret); - ASSERT_EQ(ret, TDM_ERROR_OPERATION_FAILED); - ASSERT_EQ(dpy, NULL); + EXPECT_EQ(ret, TDM_ERROR_OPERATION_FAILED); + EXPECT_EQ(dpy, NULL); } TEST_P(TDMEnv, DisplayInitFewTimes) @@ -108,12 +108,12 @@ TEST_P(TDMEnv, DisplayInitFewTimes) for (d = 0; d < 10; d++) { dpy[d] = tdm_display_init(&ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(dpy[d], NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(dpy[d], NULL); } for (d = 0; d < 9; d++) - ASSERT_EQ(dpy[d], dpy[d + 1]); + EXPECT_EQ(dpy[d], dpy[d + 1]); for (d = 0; d < 10; d++) tdm_display_deinit(dpy[d]); @@ -126,11 +126,11 @@ TEST_P(TDMEnv, DisplayInitDeinitWithTBM) tdm_error ret; bufmgr = tbm_bufmgr_init(-1); - ASSERT_NE(bufmgr, NULL); + EXPECT_NE(bufmgr, NULL); dpy = tdm_display_init(&ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(dpy, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(dpy, NULL); tdm_display_deinit(dpy); tbm_bufmgr_deinit(bufmgr); diff --git a/haltests/src/tc_tdm_event_loop.cpp b/haltests/src/tc_tdm_event_loop.cpp index d85b1d9..826ebd3 100644 --- a/haltests/src/tc_tdm_event_loop.cpp +++ b/haltests/src/tc_tdm_event_loop.cpp @@ -73,20 +73,20 @@ TEST_P(TDMEventLoop, EventLoopAddFdHandler) bool done; int len; - ASSERT_EQ(pipe(pipes), 0); + EXPECT_EQ(pipe(pipes), 0); done = false; source = tdm_event_loop_add_fd_handler(dpy, pipes[0], TDM_EVENT_LOOP_READABLE, _tc_tdm_event_loop_fd_cb, &done, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(source, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(source, NULL); len = write(pipes[1], "hello", 5); - ASSERT_EQ(len, 5); + EXPECT_EQ(len, 5); //TODO // while (!done) -// ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); +// EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); tdm_event_loop_source_remove(source); @@ -100,8 +100,8 @@ TEST_P(TDMEventLoop, EventLoopAddFdHandlerNullObject) tdm_event_loop_source *source; source = tdm_event_loop_add_fd_handler(NULL, 0, TDM_EVENT_LOOP_READABLE, _tc_tdm_event_loop_fd_cb, NULL, &ret); - ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(source, NULL); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(source, NULL); } TEST_P(TDMEventLoop, EventLoopAddFdHandlerNullOther) @@ -109,8 +109,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_EQ(ret, TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(source, NULL); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(source, NULL); } TEST_P(TDMEventLoop, EventLoopSourceFdUpdate) @@ -121,22 +121,22 @@ TEST_P(TDMEventLoop, EventLoopSourceFdUpdate) bool done; int len; - ASSERT_EQ(pipe(pipes), 0); + EXPECT_EQ(pipe(pipes), 0); done = false; source = tdm_event_loop_add_fd_handler(dpy, pipes[0], TDM_EVENT_LOOP_WRITABLE, _tc_tdm_event_loop_fd_cb, &done, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(source, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(source, NULL); - ASSERT_EQ(tdm_event_loop_source_fd_update(source, TDM_EVENT_LOOP_READABLE), TDM_ERROR_NONE); + EXPECT_EQ(tdm_event_loop_source_fd_update(source, TDM_EVENT_LOOP_READABLE), TDM_ERROR_NONE); len = write(pipes[1], "hello", 5); - ASSERT_EQ(len, 5); + EXPECT_EQ(len, 5); //TODO // while (!done) -// ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); +// EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); tdm_event_loop_source_remove(source); @@ -146,7 +146,7 @@ TEST_P(TDMEventLoop, EventLoopSourceFdUpdate) TEST_P(TDMEventLoop, EventLoopSourceFdUpdateNullObject) { - ASSERT_EQ(tdm_event_loop_source_fd_update(NULL, TDM_EVENT_LOOP_READABLE), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_event_loop_source_fd_update(NULL, TDM_EVENT_LOOP_READABLE), TDM_ERROR_INVALID_PARAMETER); } static tdm_error @@ -163,8 +163,8 @@ TEST_P(TDMEventLoop, EventLoopAddTimerHandler) tdm_error ret; tdm_event_loop_source *source; source = tdm_event_loop_add_timer_handler(dpy, _tc_tdm_event_loop_timer_cb, NULL, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(source, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(source, NULL); tdm_event_loop_source_remove(source); } @@ -173,8 +173,8 @@ TEST_P(TDMEventLoop, EventLoopAddTimerHandlerNullObject) tdm_error ret; tdm_event_loop_source *source; source = tdm_event_loop_add_timer_handler(NULL, _tc_tdm_event_loop_timer_cb, NULL, &ret); - ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(source, NULL); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(source, NULL); } @@ -183,8 +183,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_EQ(ret, TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(source, NULL); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(source, NULL); } TEST_P(TDMEventLoop, EventLoopSourceTimerUpdate) @@ -192,18 +192,18 @@ TEST_P(TDMEventLoop, EventLoopSourceTimerUpdate) tdm_error ret; tdm_event_loop_source *source; source = tdm_event_loop_add_timer_handler(dpy, _tc_tdm_event_loop_timer_cb, NULL, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(source, NULL); - ASSERT_EQ(tdm_event_loop_source_timer_update(source, 100), TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(source, NULL); + EXPECT_EQ(tdm_event_loop_source_timer_update(source, 100), TDM_ERROR_NONE); //TODO // while (!done) -// ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); +// EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); tdm_event_loop_source_remove(source); } TEST_P(TDMEventLoop, EventLoopSourceTimerUpdateNullObject) { - ASSERT_EQ(tdm_event_loop_source_timer_update(NULL, 100), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_event_loop_source_timer_update(NULL, 100), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMEventLoop, EventLoopSourceRemoveNullObject) diff --git a/haltests/src/tc_tdm_helper.cpp b/haltests/src/tc_tdm_helper.cpp index fa94091..56e5a43 100644 --- a/haltests/src/tc_tdm_helper.cpp +++ b/haltests/src/tc_tdm_helper.cpp @@ -56,7 +56,7 @@ void TDMHelper::TearDown(void) TEST_P(TDMHelper, HelperGetTime) { - ASSERT_GT(tdm_helper_get_time(), 0.0); + EXPECT_GT(tdm_helper_get_time(), 0.0); } TEST_P(TDMHelper, HelperDumpBufferXR24) @@ -64,7 +64,7 @@ TEST_P(TDMHelper, HelperDumpBufferXR24) tbm_surface_h buffer; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_XRGB8888); - ASSERT_NE(buffer, NULL); + EXPECT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -80,7 +80,7 @@ TEST_P(TDMHelper, HelperDumpBufferAR24) tbm_surface_h buffer; buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888); - ASSERT_NE(buffer, NULL); + EXPECT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -109,7 +109,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_NE(buffer, NULL); + EXPECT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -127,7 +127,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_NE(buffer, NULL); + EXPECT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -143,7 +143,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_NE(buffer, NULL); + EXPECT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -159,7 +159,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_NE(buffer, NULL); + EXPECT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -175,7 +175,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_NE(buffer, NULL); + EXPECT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -191,7 +191,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_NE(buffer, NULL); + EXPECT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -207,7 +207,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_NE(buffer, NULL); + EXPECT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); @@ -224,13 +224,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_NE(buffer, NULL); + EXPECT_NE(buffer, NULL); tdm_helper_get_buffer_full_size(buffer, &w, &h); - 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)); + EXPECT_NE(w, TDM_UT_INVALID_VALUE); + EXPECT_GE(w, tbm_surface_get_width(buffer)); + EXPECT_NE(h, TDM_UT_INVALID_VALUE); + EXPECT_GE(h, tbm_surface_get_height(buffer)); tbm_surface_destroy(buffer); } @@ -241,16 +241,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_NE(buffer, NULL); + EXPECT_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_NE(temp, NULL); + EXPECT_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_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_NORMAL, 0), TDM_ERROR_NONE); + EXPECT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_NORMAL, 0), TDM_ERROR_NONE); tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name()); @@ -264,16 +264,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_NE(buffer, NULL); + EXPECT_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_NE(temp, NULL); + EXPECT_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_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_FLIPPED, 0), TDM_ERROR_NONE); + EXPECT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_FLIPPED, 0), TDM_ERROR_NONE); tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name()); @@ -287,16 +287,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_NE(buffer, NULL); + EXPECT_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_NE(temp, NULL); + EXPECT_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_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_90, 0), TDM_ERROR_NONE); + EXPECT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_90, 0), TDM_ERROR_NONE); tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name()); @@ -310,16 +310,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_NE(buffer, NULL); + EXPECT_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_NE(temp, NULL); + EXPECT_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_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_180, 0), TDM_ERROR_NONE); + EXPECT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_180, 0), TDM_ERROR_NONE); tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name()); @@ -333,16 +333,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_NE(buffer, NULL); + EXPECT_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_NE(temp, NULL); + EXPECT_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_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_270, 0), TDM_ERROR_NONE); + EXPECT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_270, 0), TDM_ERROR_NONE); tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name()); @@ -356,16 +356,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_NE(buffer, NULL); + EXPECT_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_NE(temp, NULL); + EXPECT_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_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_NORMAL, 0), TDM_ERROR_OPERATION_FAILED); + EXPECT_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); @@ -374,10 +374,10 @@ TEST_P(TDMHelper, HelperConvertBufferYUV420) TEST_P(TDMHelper, HelperGetFD) { int fd = tdm_helper_get_fd("TDM_DRM_MASTER_FD"); - ASSERT_GE(fd, 0); + EXPECT_GE(fd, 0); close(fd); fd = tdm_helper_get_fd("BLURBLUR"); - ASSERT_EQ(fd, -1); + EXPECT_EQ(fd, -1); } TEST_P(TDMHelper, HelperSetFD) @@ -409,8 +409,8 @@ TEST_P(TDMHelper, HelperCaptureOutput) tbm_surface_h dump; output = tdm_display_get_output(dpy, o, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); if (!tc_tdm_output_is_connected(output)) continue; @@ -418,12 +418,12 @@ TEST_P(TDMHelper, HelperCaptureOutput) if (tc_tdm_output_is_hwc_enable(outputs[o])) TDM_UT_SKIP_FLAG(0); - ASSERT_EQ(tc_tdm_output_prepare(dpy, output, true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, output, true), true); dump = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888); - ASSERT_NE(dump, NULL); + EXPECT_NE(dump, NULL); - ASSERT_EQ(tdm_helper_capture_output(output, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, + EXPECT_EQ(tdm_helper_capture_output(output, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, _tc_tdm_helper_capture_cb, NULL), TDM_ERROR_NONE); tdm_helper_dump_buffer_str(dump, NULL, (char*)typeid(*this).name()); @@ -437,7 +437,7 @@ TEST_P(TDMHelper, HelperCaptureOutputNullObject) { tbm_surface_h dump = (tbm_surface_h)TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, + EXPECT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, _tc_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } @@ -446,14 +446,14 @@ 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_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); tdm_helper_output_commit_per_vblank_enabled(output); } tbm_surface_h dump = (tbm_surface_h)TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, + EXPECT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, _tc_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } @@ -465,11 +465,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_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); if (!tc_tdm_output_is_connected(output)) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, output, true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, output, true), true); } tdm_helper_get_display_information(dpy, reply, &len); @@ -491,17 +491,17 @@ TEST_P(TDMHelper, HelperGetDisplayInformationNullOther) TEST_P(TDMHelper, HelperCommitPerVblankEnabled) { - ASSERT_EQ(tdm_helper_commit_per_vblank_enabled(dpy), 0); + EXPECT_EQ(tdm_helper_commit_per_vblank_enabled(dpy), 0); } TEST_P(TDMHelper, HelperCommitPerVblankEnabledNullOBject) { - ASSERT_EQ(tdm_helper_commit_per_vblank_enabled(NULL), 0); + EXPECT_EQ(tdm_helper_commit_per_vblank_enabled(NULL), 0); } TEST_P(TDMHelper, HelperOutputCommitPerVblankEnabledNullObject) { - ASSERT_EQ(tdm_helper_output_commit_per_vblank_enabled(NULL), -1); + EXPECT_EQ(tdm_helper_output_commit_per_vblank_enabled(NULL), -1); } #ifdef TDM_UT_TEST_WITH_PARAMS diff --git a/haltests/src/tc_tdm_hwc.cpp b/haltests/src/tc_tdm_hwc.cpp index 8307bed..869c9c2 100644 --- a/haltests/src/tc_tdm_hwc.cpp +++ b/haltests/src/tc_tdm_hwc.cpp @@ -74,8 +74,8 @@ TEST_P(TDMHwc, CreateWindowFailNull) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(NULL, tdm_hwc_create_window(NULL, &error)); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_EQ(NULL, tdm_hwc_create_window(NULL, &error)); + EXPECT_NE(TDM_ERROR_NONE, error); } TEST_P(TDMHwc, CreateWindowSuccessful) @@ -90,11 +90,11 @@ TEST_P(TDMHwc, CreateWindowSuccessful) hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { hw = tdm_hwc_create_window(hwc, &error); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); tdm_hwc_window_destroy(hw); } else { - ASSERT_EQ(NULL, tdm_hwc_create_window(hwc, &error)); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_EQ(NULL, tdm_hwc_create_window(hwc, &error)); + EXPECT_NE(TDM_ERROR_NONE, error); } } } @@ -107,7 +107,7 @@ TEST_P(TDMHwc, GetSupportedFormatsFailNull) tdm_error error; error = tdm_hwc_get_video_supported_formats(NULL, NULL, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } TEST_P(TDMHwc, GetSupportedFormatsSuccessful) @@ -124,13 +124,13 @@ TEST_P(TDMHwc, GetSupportedFormatsSuccessful) if (hwc) { error = tdm_hwc_get_video_supported_formats(hwc, &formats, &count); if (error != TDM_ERROR_NOT_IMPLEMENTED) { - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); if (count > 0) - ASSERT_NE(NULL, formats); + EXPECT_NE(NULL, formats); } } else { error = tdm_hwc_get_video_supported_formats(hwc, &formats, &count); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } } } @@ -150,16 +150,16 @@ TEST_P(TDMHwc, GetAvailableVideoPropertiesFailNull) hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { error = tdm_hwc_get_video_available_properties(NULL, &props, &count); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); error = tdm_hwc_get_video_available_properties(hwc, NULL, &count); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); error = tdm_hwc_get_video_available_properties(hwc, &props, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } else { error = tdm_hwc_get_video_available_properties(hwc, &props, &count); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } } } @@ -177,10 +177,10 @@ TEST_P(TDMHwc, GetAvailableVideoPropertiesSuccess) hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { error = tdm_hwc_get_video_available_properties(hwc, &props, &count); - ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error); + EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error); } else { error = tdm_hwc_get_video_available_properties(hwc, &props, &count); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } } } @@ -198,13 +198,13 @@ TEST_P(TDMHwc, GetAvailableCapabilitiesFailNull) hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { error = tdm_hwc_get_capabilities(NULL, &hwc_caps); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); error = tdm_hwc_get_capabilities(hwc, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } else { error = tdm_hwc_get_capabilities(hwc, &hwc_caps); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } } } @@ -221,10 +221,10 @@ TEST_P(TDMHwc, GetAvailableCapabilitiesSuccess) hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { error = tdm_hwc_get_capabilities(hwc, &hwc_caps); - ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error); + EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error); } else { error = tdm_hwc_get_capabilities(hwc, &hwc_caps); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } } } @@ -243,16 +243,16 @@ TEST_P(TDMHwc, GetAvailablePropertiesFailNullWin) hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { error = tdm_hwc_get_available_properties(NULL, &props, &count); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); error = tdm_hwc_get_available_properties(hwc, NULL, &count); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); error = tdm_hwc_get_available_properties(hwc, &props, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } else { error = tdm_hwc_get_available_properties(hwc, &props, &count); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } } } @@ -270,10 +270,10 @@ TEST_P(TDMHwc, GetAvailablePropertiesSuccess) hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { error = tdm_hwc_get_available_properties(hwc, &props, &count); - ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error); + EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error); } else { error = tdm_hwc_get_available_properties(hwc, &props, &count); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } } @@ -292,13 +292,13 @@ TEST_P(TDMHwc, GetClientTargetBufferQueueFailNullObject) hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { queue = tdm_hwc_get_client_target_buffer_queue(NULL, &error); - ASSERT_NE(TDM_ERROR_NONE, error); - ASSERT_EQ(NULL, queue); + EXPECT_NE(TDM_ERROR_NONE, error); + EXPECT_EQ(NULL, queue); queue = tdm_hwc_get_client_target_buffer_queue(NULL, NULL); - ASSERT_EQ(NULL, queue); + EXPECT_EQ(NULL, queue); } else { - ASSERT_EQ(NULL, queue); + EXPECT_EQ(NULL, queue); } } } @@ -315,12 +315,12 @@ TEST_P(TDMHwc, GetClientTargetBufferQueueFailNoHwc) hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error); - ASSERT_NE(TDM_ERROR_NONE, error); - ASSERT_EQ(NULL, queue); + EXPECT_NE(TDM_ERROR_NONE, error); + EXPECT_EQ(NULL, queue); } else { queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error); - ASSERT_NE(TDM_ERROR_NONE, error); - ASSERT_EQ(NULL, queue); + EXPECT_NE(TDM_ERROR_NONE, error); + EXPECT_EQ(NULL, queue); } } } @@ -334,26 +334,26 @@ TEST_P(TDMHwc, GetClientTargetBufferQueueSuccessful) tbm_surface_queue_h queue = NULL; for (int o = 0; o < output_count; o++) { - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error); tbm_surface_queue_destroy(queue); - ASSERT_EQ(TDM_ERROR_NONE, error); - ASSERT_NE(NULL, queue); + EXPECT_EQ(TDM_ERROR_NONE, error); + EXPECT_NE(NULL, queue); queue = tdm_hwc_get_client_target_buffer_queue(hwc, NULL); tbm_surface_queue_destroy(queue); - ASSERT_EQ(TDM_ERROR_NONE, error); - ASSERT_NE(NULL, queue); + EXPECT_EQ(TDM_ERROR_NONE, error); + EXPECT_NE(NULL, queue); } else { queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error); - ASSERT_NE(TDM_ERROR_NONE, error); - ASSERT_EQ(NULL, queue); + EXPECT_NE(TDM_ERROR_NONE, error); + EXPECT_EQ(NULL, queue); queue = tdm_hwc_get_client_target_buffer_queue(hwc, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); - ASSERT_EQ(NULL, queue); + EXPECT_NE(TDM_ERROR_NONE, error); + EXPECT_EQ(NULL, queue); } } } @@ -368,11 +368,11 @@ TEST_P(TDMHwc, SetClientTargetBufferFailNullOutput) target_buff = tbm_surface_internal_create_with_flags(720, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT); - ASSERT_NE(NULL, target_buff); + EXPECT_NE(NULL, target_buff); error = tdm_hwc_set_client_target_buffer(NULL, target_buff, damage); tbm_surface_internal_destroy(target_buff); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } TEST_P(TDMHwc, SetClientTargetBufferSuccessfulSetBuff) @@ -386,21 +386,21 @@ TEST_P(TDMHwc, SetClientTargetBufferSuccessfulSetBuff) tbm_surface_h target_buff = NULL; for (int o = 0; o < output_count; o++) { - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { - ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); - ASSERT_NE(mode, NULL); + EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); + EXPECT_NE(mode, NULL); target_buff = tbm_surface_internal_create_with_flags(mode->hdisplay, mode->vdisplay, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT); - ASSERT_NE(NULL, target_buff); + EXPECT_NE(NULL, target_buff); error = tdm_hwc_set_client_target_buffer(hwc, target_buff, damage); tbm_surface_internal_destroy(target_buff); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); } else { error = tdm_hwc_set_client_target_buffer(hwc, target_buff, damage); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } } } @@ -414,14 +414,14 @@ TEST_P(TDMHwc, SetClientTargetBufferSuccessfulResetBuff) tdm_region damage = {.num_rects = 0, .rects = NULL}; for (int o = 0; o < output_count; o++) { - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { error = tdm_hwc_set_client_target_buffer(hwc, NULL, damage); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); } else { error = tdm_hwc_set_client_target_buffer(hwc, NULL, damage); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } } } @@ -436,16 +436,16 @@ TEST_P(TDMHwc, ValidateFailNull) uint32_t num_types; error = tdm_hwc_validate(NULL, NULL, 0, &num_types); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); for (int o = 0; o < output_count; o++) { hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { error = tdm_hwc_validate(hwc, NULL, 0, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } else { error = tdm_hwc_validate(hwc, NULL, 0, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } } } @@ -460,16 +460,16 @@ TEST_P(TDMHwc, GetChangedCompositionTypesFailNull) uint32_t num_elements; error = tdm_hwc_get_changed_composition_types(NULL, &num_elements, NULL, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); for (int o = 0; o < output_count; o++) { hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { error = tdm_hwc_get_changed_composition_types(hwc, NULL, NULL, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } else { error = tdm_hwc_get_changed_composition_types(hwc, NULL, NULL, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } } } @@ -480,7 +480,7 @@ TEST_P(TDMHwc, AcceptChangesFailNull) TDM_UT_SKIP_FLAG(has_outputs); error = tdm_hwc_accept_validation(NULL); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } TEST_P(TDMHwc, AcceptChangesFailNoHwc) @@ -492,10 +492,10 @@ TEST_P(TDMHwc, AcceptChangesFailNoHwc) hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { error = tdm_hwc_accept_validation(hwc); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); } else { error = tdm_hwc_accept_validation(hwc); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } } } @@ -513,18 +513,18 @@ TEST_P(TDMHwc, AcceptChangesSuccessful) uint32_t get_num = 0; for (int o = 0; o < output_count; o++) { - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { for (int w = 0; w < HWC_WIN_NUM; w++) { hwc_wnds[w] = tdm_hwc_create_window(hwc, &error); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); error = tdm_hwc_window_set_composition_type(hwc_wnds[w], TDM_HWC_WIN_COMPOSITION_DEVICE); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); } error = tdm_hwc_validate(hwc, hwc_wnds, HWC_WIN_NUM, &num_types); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); if (num_types > 0) { changed_hwc_window = (tdm_hwc_window **)calloc(num_types, sizeof(tdm_hwc_window *)); @@ -532,11 +532,11 @@ TEST_P(TDMHwc, AcceptChangesSuccessful) get_num = num_types; error = tdm_hwc_get_changed_composition_types(hwc, &get_num, changed_hwc_window, composition_types); - ASSERT_EQ(TDM_ERROR_NONE, error); - ASSERT_EQ(get_num, num_types); + EXPECT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(get_num, num_types); error = tdm_hwc_accept_validation(hwc); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); free(composition_types); free(changed_hwc_window); @@ -545,7 +545,7 @@ TEST_P(TDMHwc, AcceptChangesSuccessful) for (int w = 0; w < HWC_WIN_NUM; w++) tdm_hwc_window_destroy(hwc_wnds[w]); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); } } } @@ -556,7 +556,7 @@ TEST_P(TDMHwc, CommitFailNull) TDM_UT_SKIP_FLAG(has_outputs); error = tdm_hwc_commit(NULL, 1, NULL, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } TEST_P(TDMHwc, CommitSuccessful) @@ -572,18 +572,18 @@ TEST_P(TDMHwc, CommitSuccessful) uint32_t get_num = 0; for (int o = 0; o < output_count; o++) { - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { for (int w = 0; w < HWC_WIN_NUM; w++) { hwc_wnds[w] = tdm_hwc_create_window(hwc, &error); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); error = tdm_hwc_window_set_composition_type(hwc_wnds[w], TDM_HWC_WIN_COMPOSITION_DEVICE); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); } error = tdm_hwc_validate(hwc, hwc_wnds, HWC_WIN_NUM, &num_types); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); if (num_types > 0) { changed_hwc_window = (tdm_hwc_window **)calloc(num_types, sizeof(tdm_hwc_window *)); @@ -591,23 +591,23 @@ TEST_P(TDMHwc, CommitSuccessful) get_num = num_types; error = tdm_hwc_get_changed_composition_types(hwc, &get_num, changed_hwc_window, composition_types); - ASSERT_EQ(TDM_ERROR_NONE, error); - ASSERT_EQ(get_num, num_types); + EXPECT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(get_num, num_types); error = tdm_hwc_accept_validation(hwc); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); free(composition_types); free(changed_hwc_window); } error = tdm_hwc_commit(hwc, 0, _tc_tdm_hwc_commit_cb, NULL); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); for (int w = 0; w < HWC_WIN_NUM; w++) tdm_hwc_window_destroy(hwc_wnds[w]); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); } } } @@ -627,10 +627,10 @@ TEST_P(TDMHwc, SetPropertyFailNull) hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { error = tdm_hwc_set_property(NULL, 0, value); - ASSERT_EQ(TDM_ERROR_INVALID_PARAMETER, error); + EXPECT_EQ(TDM_ERROR_INVALID_PARAMETER, error); } else { error = tdm_hwc_set_property(hwc, 0, value); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } } } @@ -651,18 +651,18 @@ TEST_P(TDMHwc, SetPropertySuccess) hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { error = tdm_hwc_get_available_properties(hwc, &props, &count); - ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error); + EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error); if (count == 0) { error = tdm_hwc_set_property(hwc, 0, value); - ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error); + EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error); } else { error = tdm_hwc_set_property(hwc, props[0].id, value); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); } } else { error = tdm_hwc_set_property(hwc, 0, value); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } } } @@ -680,10 +680,10 @@ TEST_P(TDMHwc, GetPropertyFailNull) hwc = tdm_output_get_hwc(outputs[o], &error); if (hwc) { error = tdm_hwc_get_property(NULL, 0, &value); - ASSERT_EQ(TDM_ERROR_INVALID_PARAMETER, error); + EXPECT_EQ(TDM_ERROR_INVALID_PARAMETER, error); } else { error = tdm_hwc_get_property(hwc, 0, &value); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } } } @@ -703,18 +703,18 @@ TEST_P(TDMHwc, GetPropertySuccess) if (hwc) { error = tdm_hwc_get_available_properties(hwc, &props, &count); - ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error); + EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error); if (count == 0) { error = tdm_hwc_get_property(hwc, 0, &value); - ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error); + EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error); } else { error = tdm_hwc_get_property(hwc, props[0].id, &value); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); } } else { error = tdm_hwc_get_property(hwc, 0, &value); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } } } diff --git a/haltests/src/tc_tdm_hwc_window.cpp b/haltests/src/tc_tdm_hwc_window.cpp index 3f91ace..e407e7b 100644 --- a/haltests/src/tc_tdm_hwc_window.cpp +++ b/haltests/src/tc_tdm_hwc_window.cpp @@ -74,7 +74,7 @@ TEST_P(TDMHwcWindow, DestroyWindowSuccessful) hwc = tdm_output_get_hwc(hwc, &error); if (hwc) { hw = tdm_hwc_create_window(hwc, &error); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); if (hw) tdm_hwc_window_destroy(hw); } @@ -90,11 +90,11 @@ TEST_P(TDMHwcWindow, GetBufferQueueFailNull) tbm_surface_queue_h queue = NULL; queue = tdm_hwc_window_acquire_buffer_queue(NULL, &error); - ASSERT_NE(TDM_ERROR_NONE, error); - ASSERT_EQ(NULL, queue); + EXPECT_NE(TDM_ERROR_NONE, error); + EXPECT_EQ(NULL, queue); queue = tdm_hwc_window_acquire_buffer_queue(NULL, NULL); - ASSERT_EQ(NULL, queue); + EXPECT_EQ(NULL, queue); } TEST_P(TDMHwcWindow, GetBufferQueueSuccessful) @@ -113,7 +113,7 @@ TEST_P(TDMHwcWindow, GetBufferQueueSuccessful) if (hwc) { for (w = 0; w < HWC_WIN_NUM; w++) { hwc_wins[w] = tdm_hwc_create_window(hwc, &error); - ASSERT_NE(NULL, hwc_wins[w]); + EXPECT_NE(NULL, hwc_wins[w]); } info.src_config.format = TBM_FORMAT_ARGB8888; @@ -124,16 +124,16 @@ TEST_P(TDMHwcWindow, GetBufferQueueSuccessful) for (w = 0; w < HWC_WIN_NUM; w++) { error = tdm_hwc_window_set_info(hwc_wins[w], &info); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); queue = tdm_hwc_window_acquire_buffer_queue(hwc_wins[w], &error); tdm_hwc_window_release_buffer_queue(hwc_wins[w], queue); - ASSERT_EQ(TDM_ERROR_NONE, error); - ASSERT_NE(NULL, queue); + EXPECT_EQ(TDM_ERROR_NONE, error); + EXPECT_NE(NULL, queue); queue = tdm_hwc_window_acquire_buffer_queue(hwc_wins[w], NULL); tdm_hwc_window_release_buffer_queue(hwc_wins[w], queue); - ASSERT_NE(NULL, queue); + EXPECT_NE(NULL, queue); } for (w = 0; w < HWC_WIN_NUM; w++) @@ -151,7 +151,7 @@ TEST_P(TDMHwcWindow, SetCompositionTypeFailNull) tdm_error error = TDM_ERROR_NONE; error = tdm_hwc_window_set_composition_type(NULL, TDM_HWC_WIN_COMPOSITION_DEVICE); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } TEST_P(TDMHwcWindow, SetCompositionTypeFailInvalieCompositionType) @@ -166,9 +166,9 @@ TEST_P(TDMHwcWindow, SetCompositionTypeFailInvalieCompositionType) hwc = tdm_output_get_hwc(hwc, &error); if (hwc) { hwc_win = tdm_hwc_create_window(hwc, &error); - ASSERT_NE(NULL, hwc_win); + EXPECT_NE(NULL, hwc_win); error = tdm_hwc_window_set_composition_type(hwc_win, tdm_hwc_window_composition(TDM_HWC_WIN_COMPOSITION_NONE - 1)); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); tdm_hwc_window_destroy(hwc_win); } } @@ -188,16 +188,16 @@ TEST_P(TDMHwcWindow, SetCompositionTypeSuccessful) if (hwc) { for (w = 0; w < HWC_WIN_NUM; w++) { hwc_wins[w] = tdm_hwc_create_window(hwc, &error); - ASSERT_NE(NULL, hwc_wins[w]); + EXPECT_NE(NULL, hwc_wins[w]); } for (w = 0; w < HWC_WIN_NUM; w++) { error = tdm_hwc_window_set_composition_type(hwc_wins[w], TDM_HWC_WIN_COMPOSITION_DEVICE); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); error = tdm_hwc_window_set_composition_type(hwc_wins[w], TDM_HWC_WIN_COMPOSITION_CLIENT); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); error = tdm_hwc_window_set_composition_type(hwc_wins[w], TDM_HWC_WIN_COMPOSITION_CURSOR); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); } for (w = 0; w < HWC_WIN_NUM; w++) @@ -215,7 +215,7 @@ TEST_P(TDMHwcWindow, SetBufferDamageFailNullHwcWindow) tdm_region damage = {.num_rects = 0, .rects = NULL}; error = tdm_hwc_window_set_buffer_damage(NULL, damage); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } TEST_P(TDMHwcWindow, SetBufferDamageFailNullDamageRects) @@ -231,9 +231,9 @@ TEST_P(TDMHwcWindow, SetBufferDamageFailNullDamageRects) hwc = tdm_output_get_hwc(hwc, &error); if (hwc) { hwc_win = tdm_hwc_create_window(hwc, &error); - ASSERT_NE(NULL, hwc_win); + EXPECT_NE(NULL, hwc_win); error = tdm_hwc_window_set_buffer_damage(hwc_win, damage); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); tdm_hwc_window_destroy(hwc_win); } } @@ -254,9 +254,9 @@ TEST_P(TDMHwcWindow, SetBufferDamageSuccessful) if (hwc) { for (int w = 0; w < HWC_WIN_NUM; w++) { hwc_wins[w] = tdm_hwc_create_window(hwc, &error); - ASSERT_NE(NULL, hwc_wins[w]); + EXPECT_NE(NULL, hwc_wins[w]); error = tdm_hwc_window_set_buffer_damage(hwc_wins[w], damage); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); tdm_hwc_window_destroy(hwc_wins[w]); } } @@ -274,15 +274,15 @@ TEST_P(TDMHwcWindow, SetInfoFailNull) tdm_hwc_window_info info = { 0 }; error = tdm_hwc_window_set_info(NULL, &info); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); for (int o = 0; o < output_count; o++) { hwc = tdm_output_get_hwc(hwc, &error); if (hwc) { hwc_win = tdm_hwc_create_window(hwc, &error); - ASSERT_NE(NULL, hwc_win); + EXPECT_NE(NULL, hwc_win); error = tdm_hwc_window_set_info(hwc_win, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); tdm_hwc_window_destroy(hwc_win); } } @@ -301,9 +301,9 @@ TEST_P(TDMHwcWindow, SetInfoSuccessful) hwc = tdm_output_get_hwc(hwc, &error); if (hwc) { hwc_win = tdm_hwc_create_window(hwc, &error); - ASSERT_NE(NULL, hwc_win); + EXPECT_NE(NULL, hwc_win); error = tdm_hwc_window_set_info(hwc_win, &info); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); tdm_hwc_window_destroy(hwc_win); } } @@ -317,7 +317,7 @@ TEST_P(TDMHwcWindow, SetBufferFailNull) tdm_error error = TDM_ERROR_NONE; error = tdm_hwc_window_set_buffer(NULL, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } TEST_P(TDMHwcWindow, SetBufferSuccessful) @@ -334,18 +334,18 @@ TEST_P(TDMHwcWindow, SetBufferSuccessful) if (hwc) { for (int w = 0; w < HWC_WIN_NUM; w++) { hwc_wins[w] = tdm_hwc_create_window(hwc, &error); - ASSERT_NE(NULL, hwc_wins[w]); + EXPECT_NE(NULL, hwc_wins[w]); buffer = tbm_surface_create(256, 256, TBM_FORMAT_ARGB8888); - ASSERT_NE(NULL, buffer); + EXPECT_NE(NULL, buffer); error = tdm_hwc_window_set_buffer(hwc_wins[w], buffer); tbm_surface_destroy(buffer); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); /* set NULL to the buffer */ error = tdm_hwc_window_set_buffer(hwc_wins[w], NULL); - ASSERT_EQ(TDM_ERROR_NONE, error); + EXPECT_EQ(TDM_ERROR_NONE, error); tdm_hwc_window_destroy(hwc_wins[w]); } @@ -363,7 +363,7 @@ TEST_P(TDMHwcWindow, SetPropertyFailNull) int id = 1; error = tdm_hwc_window_set_property(NULL, id, value); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); } TEST_P(TDMHwcWindow, SetPropertyFailWrongId) @@ -380,9 +380,9 @@ TEST_P(TDMHwcWindow, SetPropertyFailWrongId) hwc = tdm_output_get_hwc(hwc, &error); if (hwc) { hwc_win = tdm_hwc_create_window(hwc, &error); - ASSERT_NE(NULL, hwc_win); + EXPECT_NE(NULL, hwc_win); error = tdm_hwc_window_set_property(hwc_win, id, value); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); tdm_hwc_window_destroy(hwc_win); } } @@ -400,15 +400,15 @@ TEST_P(TDMHwcWindow, GetPropertyFailNull) int id = 1; error = tdm_hwc_window_get_property(NULL, id, &value); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); for (int o = 0; o < output_count; o++) { hwc = tdm_output_get_hwc(hwc, &error); if (hwc) { hwc_win = tdm_hwc_create_window(hwc, &error); - ASSERT_NE(NULL, hwc_win); + EXPECT_NE(NULL, hwc_win); error = tdm_hwc_window_get_property(hwc_win, id, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); tdm_hwc_window_destroy(hwc_win); } } @@ -428,9 +428,9 @@ TEST_P(TDMHwcWindow, GetPropertyFailWrongId) hwc = tdm_output_get_hwc(hwc, &error); if (hwc) { hwc_win = tdm_hwc_create_window(hwc, &error); - ASSERT_NE(NULL, hwc_win); + EXPECT_NE(NULL, hwc_win); error = tdm_hwc_window_get_property(hwc_win, id, &value); - ASSERT_NE(TDM_ERROR_NONE, error); + EXPECT_NE(TDM_ERROR_NONE, error); tdm_hwc_window_destroy(hwc_win); } } diff --git a/haltests/src/tc_tdm_layer.cpp b/haltests/src/tc_tdm_layer.cpp index db08461..1e1aef6 100644 --- a/haltests/src/tc_tdm_layer.cpp +++ b/haltests/src/tc_tdm_layer.cpp @@ -76,17 +76,17 @@ void TDMLayer::SetUp(void) if (tc_tdm_output_is_hwc_enable(outputs[o])) continue; - ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE); - ASSERT_GT(count, 0); + EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE); + EXPECT_GT(count, 0); layer_count += count; layers = (tdm_layer**)realloc(layers, sizeof(tdm_layer*) * layer_count); - ASSERT_NE(layers, NULL); + EXPECT_NE(layers, NULL); for (int l = 0; l < count; l++) { tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret); - ASSERT_NE(layer, NULL); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(layer, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); layers[old_layer_count + l] = layer; } } @@ -98,7 +98,7 @@ void TDMLayer::SetUp(void) void TDMLayer::TearDown(void) { for (int l = 0; l < layer_count; l++) { - ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); } free(layers); @@ -463,8 +463,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_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); } } @@ -474,8 +474,8 @@ TEST_P(TDMLayer, LayerGetOutputNullObject) tdm_error ret; tdm_output *output = tdm_layer_get_output(NULL, &ret); - ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(output, NULL); } TEST_P(TDMLayer, LayerGetOutputNullParam) @@ -484,7 +484,7 @@ TEST_P(TDMLayer, LayerGetOutputNullParam) for (int l = 0; l < layer_count; l++) { tdm_output *output = tdm_layer_get_output(layers[l], NULL); - ASSERT_NE(output, NULL); + EXPECT_NE(output, NULL); } } @@ -494,8 +494,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_EQ(tdm_layer_get_capabilities(layers[l], &capabilities), TDM_ERROR_NONE); - ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_layer_get_capabilities(layers[l], &capabilities), TDM_ERROR_NONE); + EXPECT_NE(capabilities, TDM_UT_INVALID_VALUE); } } @@ -504,14 +504,14 @@ TEST_P(TDMLayer, LayerGetCapabilitiesNullObject) TDM_UT_SKIP_FLAG(has_layers); tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_layer_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(capabilities, TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_layer_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(capabilities, TDM_UT_INVALID_VALUE); } TEST_P(TDMLayer, LayerGetCapabilitiesNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_get_capabilities(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_get_capabilities(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerGetAvailableFormats) @@ -523,9 +523,9 @@ TEST_P(TDMLayer, LayerGetAvailableFormats) continue; const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_layer_get_available_formats(layers[l], &formats, &count), TDM_ERROR_NONE); - ASSERT_NE(formats, NULL); - ASSERT_GT(count, 0); + EXPECT_EQ(tdm_layer_get_available_formats(layers[l], &formats, &count), TDM_ERROR_NONE); + EXPECT_NE(formats, NULL); + EXPECT_GT(count, 0); } } @@ -535,9 +535,9 @@ TEST_P(TDMLayer, LayerGetAvailableFormatsNullObject) const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE; int 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); + EXPECT_EQ(tdm_layer_get_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE); + EXPECT_EQ(count, TDM_UT_INVALID_VALUE); } TEST_P(TDMLayer, LayerGetAvailableFormatsNullOther) @@ -545,7 +545,7 @@ TEST_P(TDMLayer, LayerGetAvailableFormatsNullOther) TDM_UT_SKIP_FLAG(has_layers); if (!tc_tdm_layer_is_avaiable(layers[0])) return; - ASSERT_EQ(tdm_layer_get_available_formats(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_get_available_formats(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerGetAvailableProperties) @@ -557,10 +557,10 @@ TEST_P(TDMLayer, LayerGetAvailableProperties) continue; const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE); - ASSERT_GE(count, 0); + EXPECT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE); + EXPECT_GE(count, 0); if (count > 0) - ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE); + EXPECT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE); } } @@ -570,16 +570,16 @@ TEST_P(TDMLayer, LayerGetAvailablePropertiesNullObject) const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE; int 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); + EXPECT_EQ(tdm_layer_get_available_properties(NULL, &props, &count), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(props, (const tdm_prop *)TDM_UT_INVALID_VALUE); + EXPECT_EQ(count, TDM_UT_INVALID_VALUE); } TEST_P(TDMLayer, LayerGetAvailablePropertiesNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_get_available_properties(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_get_available_properties(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerGetZpos) @@ -587,7 +587,7 @@ TEST_P(TDMLayer, LayerGetZpos) TDM_UT_SKIP_FLAG(has_layers); bool *check_table = (bool*)calloc(layer_count, output_count); - ASSERT_NE(check_table, NULL); + EXPECT_NE(check_table, NULL); for (int l = 0; l < layer_count; l++) { if (!tc_tdm_layer_is_avaiable(layers[l])) @@ -612,15 +612,15 @@ TEST_P(TDMLayer, LayerGetZposNullObject) TDM_UT_SKIP_FLAG(has_layers); int zpos = TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_layer_get_zpos(NULL, &zpos), TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(zpos, TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_layer_get_zpos(NULL, &zpos), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(zpos, TDM_UT_INVALID_VALUE); } TEST_P(TDMLayer, LayerGetZposNullParam) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_get_zpos(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_get_zpos(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, DISABLED_LayerSetProperty) @@ -631,7 +631,7 @@ TEST_P(TDMLayer, LayerSetPropertyNullObject) { tdm_value value = {.s32 = 0}; - ASSERT_EQ(tdm_layer_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerGetProperty) @@ -644,15 +644,15 @@ TEST_P(TDMLayer, LayerGetProperty) const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE); - ASSERT_GE(count, 0); + EXPECT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE); + EXPECT_GE(count, 0); if (count > 0) { - ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE); + EXPECT_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_EQ(tdm_layer_get_property(layers[l], props[i].id, &value), TDM_ERROR_NONE); - ASSERT_NE(value.s32, TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_layer_get_property(layers[l], props[i].id, &value), TDM_ERROR_NONE); + EXPECT_NE(value.s32, TDM_UT_INVALID_VALUE); } } } @@ -663,15 +663,15 @@ TEST_P(TDMLayer, LayerGetPropertyNullObject) TDM_UT_SKIP_FLAG(has_layers); tdm_value 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); + EXPECT_EQ(tdm_layer_get_property(NULL, 0, &value), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(value.s32, TDM_UT_INVALID_VALUE); } TEST_P(TDMLayer, LayerGetPropertyNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_get_property(layers[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_get_property(layers[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerSetInfo) @@ -685,8 +685,8 @@ TEST_P(TDMLayer, LayerSetInfo) continue; tdm_info_layer info; - ASSERT_EQ(tc_tdm_layer_fill_info(layers[l], NULL, NULL, &info), true); - ASSERT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_layer_fill_info(layers[l], NULL, NULL, &info), true); + EXPECT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE); } } @@ -696,14 +696,14 @@ TEST_P(TDMLayer, LayerSetInfoNullObject) tdm_info_layer info; memset(&info, 0, sizeof info); - ASSERT_EQ(tdm_layer_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerSetInfoNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_set_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_set_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, DISABLED_LayerGetInfo) @@ -716,14 +716,14 @@ TEST_P(TDMLayer, LayerGetInfoNullObject) tdm_info_layer temp; - ASSERT_EQ(tdm_layer_get_info(NULL, &temp), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_get_info(NULL, &temp), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerGetInfoNullParam) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_get_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_get_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerGetBufferFlags) @@ -735,8 +735,8 @@ TEST_P(TDMLayer, LayerGetBufferFlags) continue; unsigned int 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); + EXPECT_EQ(tdm_layer_get_buffer_flags(layers[l], &flags), TDM_ERROR_NONE); + EXPECT_NE(flags, (unsigned int)TDM_UT_INVALID_VALUE); } } @@ -745,15 +745,15 @@ TEST_P(TDMLayer, LayerGetBufferFlagsNullObject) TDM_UT_SKIP_FLAG(has_layers); unsigned int 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); + EXPECT_EQ(tdm_layer_get_buffer_flags(NULL, &flags), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(flags, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMLayer, LayerGetBufferFlagsNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_get_buffer_flags(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_get_buffer_flags(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } static void @@ -785,17 +785,17 @@ TEST_P(TDMLayer, LayerSetBuffer) if (tc_tdm_layer_is_video_layer(layers[l])) continue; - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); + EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set buffer & commit for 100 times */ for (int t = 0; t < 10; t++) { tbm_surface_h displaying_buffer = NULL; - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true); - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); while (displaying_buffer != buffers[next_buffer]) { - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); } next_buffer++; if (next_buffer == 3) @@ -825,20 +825,20 @@ TEST_P(TDMLayer, LayerSetBufferFewTimeInOneCommit) if (tc_tdm_layer_is_video_layer(layers[l])) continue; - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); + EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set buffer & commit for 10 times */ for (int t = 0; t < 10; t++) { tbm_surface_h displaying_buffer = NULL; - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); if (next_buffer == 3) next_buffer = 0; - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true); - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); while (displaying_buffer != buffers[next_buffer]) { - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); } next_buffer++; if (next_buffer == 3) @@ -854,14 +854,14 @@ TEST_P(TDMLayer, LayerSetBufferNullObject) TDM_UT_SKIP_FLAG(has_layers); tbm_surface_h buffer = (tbm_surface_h)TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_layer_set_buffer(NULL, buffer), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_set_buffer(NULL, buffer), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerSetBufferNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_set_buffer(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_set_buffer(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerUnsetBuffer) @@ -874,7 +874,7 @@ TEST_P(TDMLayer, LayerUnsetBuffer) if (!tc_tdm_layer_is_avaiable(layers[l])) continue; - ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); } } @@ -882,7 +882,7 @@ TEST_P(TDMLayer, LayerUnsetBufferNullObject) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_unset_buffer(NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_unset_buffer(NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerUnsetBufferBeforeCommit) @@ -904,19 +904,19 @@ TEST_P(TDMLayer, LayerUnsetBufferBeforeCommit) if (tc_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); + EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set buffer & commit for 10 times */ for (int t = 0; t < 10; t++) { - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); if (next_buffer == 3) next_buffer = 0; - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); if (next_buffer == 3) next_buffer = 0; } - ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); DestroyBuffers(); } @@ -941,13 +941,13 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommit) if (tc_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); + EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); DestroyBuffers(); } @@ -973,15 +973,15 @@ TEST_P(TDMLayer, DISABLED_LayerUnsetBufferAfterTwoCommit) if (tc_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); + EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); DestroyBuffers(); } @@ -1007,17 +1007,17 @@ TEST_P(TDMLayer, DISABLED_LayerUnsetBufferAfterTwoCommitOneSetBuffer) if (tc_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); + EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true); - ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); DestroyBuffers(); } @@ -1043,19 +1043,19 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDone) if (tc_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); + EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set buffer & commit for 10 times */ - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); done = false; - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE); while (!done) { - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } - ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); DestroyBuffers(); } @@ -1081,23 +1081,23 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDoneOneCommit) if (tc_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); + EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set buffer & commit for 10 times */ - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); done = false; - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE); while (!done) { - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); next_buffer = 0; - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); DestroyBuffers(); } @@ -1109,8 +1109,8 @@ TEST_P(TDMLayer, LayerCommitDPMSOff) tdm_error ret; tdm_output *output = tdm_layer_get_output(layers[0], &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); if (!tc_tdm_output_is_connected(output)) return; @@ -1128,7 +1128,7 @@ TEST_P(TDMLayer, LayerCommitNullObject) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_commit(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_commit(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerCommitNullOther) @@ -1137,7 +1137,7 @@ TEST_P(TDMLayer, LayerCommitNullOther) tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true); - ASSERT_EQ(tdm_layer_commit(layers[0], NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_commit(layers[0], NULL, NULL), TDM_ERROR_NONE); } TEST_P(TDMLayer, LayerIsCommittingNullObject) @@ -1145,15 +1145,15 @@ TEST_P(TDMLayer, LayerIsCommittingNullObject) TDM_UT_SKIP_FLAG(has_layers); unsigned int 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); + EXPECT_EQ(tdm_layer_is_committing(NULL, &committing), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(committing, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMLayer, LayerIsCommittingNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_is_committing(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_is_committing(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerRemoveCommitHandler) @@ -1168,8 +1168,8 @@ TEST_P(TDMLayer, LayerRemoveCommitHandler) tdm_error ret; tdm_output *output = tdm_layer_get_output(layers[l], &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; @@ -1178,18 +1178,18 @@ TEST_P(TDMLayer, LayerRemoveCommitHandler) if (tc_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true); + EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true); - ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[0]), true); + EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[0]), true); for (int t = 0; t < 10; t++) { bool done1 = false, done2 = false, done3 = false; - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_remove_commit_handler(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_remove_commit_handler(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE); while (!done1 || done2 || !done3) { - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } @@ -1209,8 +1209,8 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerDifferentData) tdm_error ret; tdm_output *output = tdm_layer_get_output(layers[l], &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; @@ -1221,12 +1221,12 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerDifferentData) for (int t = 0; t < 10; t++) { bool done1 = false, done2 = false, done3 = false; - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_remove_commit_handler(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_remove_commit_handler(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); while (!done1 || !done2 || !done3) { - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1239,7 +1239,7 @@ _tc_tdm_layer_commit_cb2(tdm_layer *layer, unsigned int sequence, bool *done = (bool*)user_data; if (done) *done = true; - ASSERT_EQ(tdm_layer_remove_commit_handler(layer, _tc_tdm_layer_commit_cb2, user_data), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_remove_commit_handler(layer, _tc_tdm_layer_commit_cb2, user_data), TDM_ERROR_NONE); } TEST_P(TDMLayer, LayerRemoveCommitHandlerInHandler) @@ -1254,8 +1254,8 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerInHandler) tdm_error ret; tdm_output *output = tdm_layer_get_output(layers[l], &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; @@ -1266,11 +1266,11 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerInHandler) for (int t = 0; t < 10; t++) { bool done1 = false, done2 = false, done3 = false; - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done3), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done2), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done3), TDM_ERROR_NONE); while (!done1 || !done2 || !done3) { - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1280,14 +1280,14 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerNullObject) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_remove_commit_handler(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_remove_commit_handler(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerRemoveCommitHandlerNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_remove_commit_handler(layers[0], NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_remove_commit_handler(layers[0], NULL, NULL), TDM_ERROR_NONE); } TEST_P(TDMLayer, LayerGetDisplayingBufferNullObject) @@ -1297,8 +1297,8 @@ TEST_P(TDMLayer, LayerGetDisplayingBufferNullObject) tbm_surface_h displaying_buffer; tdm_error ret; displaying_buffer = tdm_layer_get_displaying_buffer(NULL, &ret); - ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(displaying_buffer, NULL); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(displaying_buffer, NULL); } TEST_P(TDMLayer, LayerGetDisplayingBufferNullOther) @@ -1307,7 +1307,7 @@ TEST_P(TDMLayer, LayerGetDisplayingBufferNullOther) tbm_surface_h displaying_buffer; displaying_buffer = tdm_layer_get_displaying_buffer(layers[0], NULL); - ASSERT_EQ(displaying_buffer, NULL); + EXPECT_EQ(displaying_buffer, NULL); } TEST_P(TDMLayer, LayerIsUsableNullObject) @@ -1315,8 +1315,8 @@ TEST_P(TDMLayer, LayerIsUsableNullObject) TDM_UT_SKIP_FLAG(has_layers); unsigned int 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); + EXPECT_EQ(tdm_layer_is_usable(NULL, &usable), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(usable, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMLayer, LayerSetBufferQueue) @@ -1341,28 +1341,28 @@ TEST_P(TDMLayer, LayerSetBufferQueue) if (tc_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_EQ(tc_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue), true); - ASSERT_NE(buffer_queue, NULL); + EXPECT_EQ(tc_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue), true); + EXPECT_NE(buffer_queue, NULL); - ASSERT_EQ(tc_tdm_layer_set_buffer_queue(layers[l], buffer_queue), true); + EXPECT_EQ(tc_tdm_layer_set_buffer_queue(layers[l], buffer_queue), true); - ASSERT_EQ(tdm_layer_commit(layers[l], NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_commit(layers[l], NULL, NULL), TDM_ERROR_NONE); for (int t = 0; t < 10; t++) { - ASSERT_EQ(tbm_surface_queue_dequeue(buffer_queue, &buffer), TBM_SURFACE_QUEUE_ERROR_NONE); - ASSERT_NE(buffer, NULL); + EXPECT_EQ(tbm_surface_queue_dequeue(buffer_queue, &buffer), TBM_SURFACE_QUEUE_ERROR_NONE); + EXPECT_NE(buffer, NULL); tdm_test_buffer_fill(buffer, PATTERN_SMPTE); - ASSERT_EQ(tbm_surface_queue_enqueue(buffer_queue, buffer), TBM_SURFACE_QUEUE_ERROR_NONE); + EXPECT_EQ(tbm_surface_queue_enqueue(buffer_queue, buffer), TBM_SURFACE_QUEUE_ERROR_NONE); displaying_buffer = NULL; while (displaying_buffer != buffer) { - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); } } - ASSERT_EQ(tdm_layer_unset_buffer_queue(layers[l]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_unset_buffer_queue(layers[l]), TDM_ERROR_NONE); DestroyBuffers(); } @@ -1406,28 +1406,28 @@ TEST_P(TDMLayer, LayerSetBufferQueueNullObject) tbm_surface_queue_h buffer_queue = (tbm_surface_queue_h)TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_layer_set_buffer_queue(NULL, buffer_queue), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_set_buffer_queue(NULL, buffer_queue), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerSetBufferQueueNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_set_buffer_queue(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_set_buffer_queue(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerUnsetBufferQueueNullObject) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_unset_buffer_queue(NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_unset_buffer_queue(NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerIsUsableNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_is_usable(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_is_usable(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerSetVideoPos) @@ -1440,7 +1440,7 @@ TEST_P(TDMLayer, LayerSetVideoPos) if (!tc_tdm_layer_is_video_layer(layers[l])) continue; - ASSERT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_NONE); } } @@ -1448,7 +1448,7 @@ TEST_P(TDMLayer, LayerSetVideoPosNullObject) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_set_video_pos(NULL, -1), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_layer_set_video_pos(NULL, -1), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerSetVideoPosNoVideoLayer) @@ -1462,7 +1462,7 @@ TEST_P(TDMLayer, LayerSetVideoPosNoVideoLayer) if (tc_tdm_layer_is_video_layer(layers[l])) continue; - ASSERT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_BAD_REQUEST); + EXPECT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_BAD_REQUEST); } } @@ -1479,7 +1479,7 @@ TEST_P(TDMLayer, LayerCreateCapture) capture = tdm_layer_create_capture(layers[l], &ret); if (ret == TDM_ERROR_NONE) - ASSERT_NE(capture, NULL); + EXPECT_NE(capture, NULL); } } @@ -1489,8 +1489,8 @@ TEST_P(TDMLayer, LayerCreateCaptureNullObject) tdm_error ret; tdm_capture *capture = tdm_layer_create_capture(NULL, &ret); - ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(capture, NULL); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(capture, NULL); } #ifdef TDM_UT_TEST_WITH_PARAMS diff --git a/haltests/src/tc_tdm_output.cpp b/haltests/src/tc_tdm_output.cpp index 7707c7d..764d63e 100644 --- a/haltests/src/tc_tdm_output.cpp +++ b/haltests/src/tc_tdm_output.cpp @@ -48,18 +48,18 @@ void TDMOutput::SetUp(void) { TDMDisplay::SetUp(); - ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE); - ASSERT_GE(output_count, 0); + EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE); + EXPECT_GE(output_count, 0); if (output_count > 0) { outputs = (tdm_output**)calloc(output_count, sizeof(tdm_output*)); - ASSERT_NE(outputs, NULL); + EXPECT_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_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(output, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); outputs[o] = output; } has_outputs = true; @@ -72,7 +72,7 @@ void TDMOutput::TearDown(void) { if (outputs) { for (int o = 0; o < output_count; o++) { - ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true); + EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true); tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1); tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done2); tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done3); @@ -343,8 +343,8 @@ TEST_P(TDMOutput, OutputGetBackendModule) for (int o = 0; o < output_count; o++) { tdm_error ret = (tdm_error)TDM_UT_INVALID_VALUE; - ASSERT_NE(tdm_output_get_backend_module(outputs[o], &ret), NULL); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(tdm_output_get_backend_module(outputs[o], &ret), NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); } } @@ -353,8 +353,8 @@ TEST_P(TDMOutput, OutputGetBackendModuleNullOBject) TDM_UT_SKIP_FLAG(has_outputs); tdm_error ret = (tdm_error)TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_output_get_backend_module(NULL, &ret), NULL); - ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_get_backend_module(NULL, &ret), NULL); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetBackendModuleNullOther) @@ -362,7 +362,7 @@ TEST_P(TDMOutput, OutputGetBackendModuleNullOther) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - ASSERT_NE(tdm_output_get_backend_module(outputs[o], NULL), NULL); + EXPECT_NE(tdm_output_get_backend_module(outputs[o], NULL), NULL); } } @@ -372,8 +372,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_EQ(tdm_output_get_capabilities(outputs[o], &capabilities), TDM_ERROR_NONE); - ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_output_get_capabilities(outputs[o], &capabilities), TDM_ERROR_NONE); + EXPECT_NE(capabilities, TDM_UT_INVALID_VALUE); } } @@ -382,15 +382,15 @@ TEST_P(TDMOutput, OutputGetCapabilitiesNullObject) TDM_UT_SKIP_FLAG(has_outputs); tdm_output_capability 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); + EXPECT_EQ(tdm_output_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(capabilities, (tdm_output_capability)TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetCapabilitiesNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_get_capabilities(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_get_capabilities(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetModelInfo) @@ -399,10 +399,10 @@ TEST_P(TDMOutput, OutputGetModelInfo) for (int o = 0; o < output_count; o++) { const char *maker = NULL, *model = NULL, *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); + EXPECT_EQ(tdm_output_get_model_info(outputs[o], &maker, &model, &name), TDM_ERROR_NONE); + EXPECT_NE(maker, NULL); + EXPECT_NE(model, NULL); + EXPECT_NE(name, NULL); } } @@ -414,17 +414,17 @@ TEST_P(TDMOutput, OutputGetModelInfoNullObject) const char *model = (const char*)TDM_UT_INVALID_VALUE; const char *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); + EXPECT_EQ(tdm_output_get_model_info(NULL, &maker, &model, &name), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(maker, (const char*)TDM_UT_INVALID_VALUE); + EXPECT_EQ(model, (const char*)TDM_UT_INVALID_VALUE); + EXPECT_EQ(name, (const char*)TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetModelInfoNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_get_model_info(outputs[0], NULL, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_model_info(outputs[0], NULL, NULL, NULL), TDM_ERROR_NONE); } TEST_P(TDMOutput, OutputGetConnStatus) @@ -433,8 +433,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_EQ(tdm_output_get_conn_status(outputs[o], &status), TDM_ERROR_NONE); - ASSERT_NE(status, TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_output_get_conn_status(outputs[o], &status), TDM_ERROR_NONE); + EXPECT_NE(status, TDM_UT_INVALID_VALUE); } } @@ -444,15 +444,15 @@ TEST_P(TDMOutput, OutputGetConnStatusNullObject) tdm_output_conn_status 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); + EXPECT_EQ(tdm_output_get_conn_status(NULL, &status), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetConnStatusNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_get_conn_status(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_get_conn_status(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetOutputType) @@ -461,8 +461,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_EQ(tdm_output_get_output_type(outputs[o], &type), TDM_ERROR_NONE); - ASSERT_NE(type, TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_output_get_output_type(outputs[o], &type), TDM_ERROR_NONE); + EXPECT_NE(type, TDM_UT_INVALID_VALUE); } } @@ -471,15 +471,15 @@ TEST_P(TDMOutput, OutputGetOutputTypeNullObject) TDM_UT_SKIP_FLAG(has_outputs); tdm_output_type 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); + EXPECT_EQ(tdm_output_get_output_type(NULL, &type), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(type, (tdm_output_type)TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetOutputTypeNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_get_output_type(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_get_output_type(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetLayerCount) @@ -489,11 +489,11 @@ TEST_P(TDMOutput, OutputGetLayerCount) for (int o = 0; o < output_count; o++) { int count = TDM_UT_INVALID_VALUE; if (tc_tdm_output_is_hwc_enable(outputs[o])) { - ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_BAD_REQUEST); - ASSERT_EQ(count, 0); + EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_BAD_REQUEST); + EXPECT_EQ(count, 0); } else { - ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE); - ASSERT_GT(count, 0); + EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE); + EXPECT_GT(count, 0); } } } @@ -503,15 +503,15 @@ TEST_P(TDMOutput, OutputGetLayerCountNullObject) TDM_UT_SKIP_FLAG(has_outputs); int 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); + EXPECT_EQ(tdm_output_get_layer_count(NULL, &count), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(count, TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetLayerCountNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_get_layer_count(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_get_layer_count(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetLayer) @@ -524,20 +524,20 @@ TEST_P(TDMOutput, OutputGetLayer) int layer_count = TDM_UT_INVALID_VALUE; if (tc_tdm_output_is_hwc_enable(outputs[o])) { - ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_BAD_REQUEST); - ASSERT_EQ(layer_count, 0); + EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_BAD_REQUEST); + EXPECT_EQ(layer_count, 0); layer = tdm_output_get_layer(outputs[o], 0, &ret); - ASSERT_EQ(ret, TDM_ERROR_BAD_REQUEST); - ASSERT_EQ(layer, NULL); + EXPECT_EQ(ret, TDM_ERROR_BAD_REQUEST); + EXPECT_EQ(layer, NULL); } else { - ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_NONE); - ASSERT_GT(layer_count, 0); + EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_NONE); + EXPECT_GT(layer_count, 0); for (int l = 0; l < layer_count; l++) { tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(layer, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(layer, NULL); } } } @@ -549,8 +549,8 @@ TEST_P(TDMOutput, OutputGetLayerNullObject) tdm_error ret; tdm_layer *layer = tdm_output_get_layer(NULL, 0, &ret); - ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(layer, NULL); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(layer, NULL); } TEST_P(TDMOutput, OutputGetLayerNullOther) @@ -560,10 +560,10 @@ TEST_P(TDMOutput, OutputGetLayerNullOther) tdm_layer *layer; if (tc_tdm_output_is_hwc_enable(outputs[0])) { layer = tdm_output_get_layer(outputs[0], 0, NULL); - ASSERT_EQ(layer, NULL); + EXPECT_EQ(layer, NULL); } else { layer = tdm_output_get_layer(outputs[0], 0, NULL); - ASSERT_NE(layer, NULL); + EXPECT_NE(layer, NULL); } } @@ -574,10 +574,10 @@ 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_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE); - ASSERT_GE(count, 0); + EXPECT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE); + EXPECT_GE(count, 0); if (count > 0) - ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE); + EXPECT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE); } } @@ -587,16 +587,16 @@ TEST_P(TDMOutput, OutputGetAvailablePropertiesNullObject) const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE; int 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); + EXPECT_EQ(tdm_output_get_available_properties(NULL, &props, &count), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(props, (const tdm_prop *)TDM_UT_INVALID_VALUE); + EXPECT_EQ(count, TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetAvailablePropertiesNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_get_available_properties(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_get_available_properties(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetAvailableModes) @@ -609,9 +609,9 @@ 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_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); + EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes_array, &count), TDM_ERROR_NONE); + EXPECT_GT(count, 0); + EXPECT_TRUE(modes_array != NULL && modes_array != (const tdm_output_mode *)TDM_UT_INVALID_VALUE); } } @@ -621,16 +621,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_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); + EXPECT_EQ(tdm_output_get_available_modes(NULL, &modes_array, &count), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(count, TDM_UT_INVALID_VALUE); + EXPECT_EQ(modes_array, (const tdm_output_mode *) TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetAvailableModesNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_get_available_modes(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_get_available_modes(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetAvailableSize) @@ -644,12 +644,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_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); + EXPECT_EQ(tdm_output_get_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE); + EXPECT_NE(min_w, TDM_UT_INVALID_VALUE); + EXPECT_NE(min_h, TDM_UT_INVALID_VALUE); + EXPECT_NE(max_w, TDM_UT_INVALID_VALUE); + EXPECT_NE(max_h, TDM_UT_INVALID_VALUE); + EXPECT_NE(preferred_align, TDM_UT_INVALID_VALUE); } } @@ -660,19 +660,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_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); + EXPECT_EQ(tdm_output_get_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(min_w, TDM_UT_INVALID_VALUE); + EXPECT_EQ(min_h, TDM_UT_INVALID_VALUE); + EXPECT_EQ(max_w, TDM_UT_INVALID_VALUE); + EXPECT_EQ(max_h, TDM_UT_INVALID_VALUE); + EXPECT_EQ(preferred_align, TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetAvailableSizeNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_get_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE); } TEST_P(TDMOutput, OutputGetCursorAvailableSize) @@ -682,18 +682,18 @@ TEST_P(TDMOutput, OutputGetCursorAvailableSize) int major = TDM_UT_INVALID_VALUE; int minor = TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE); + EXPECT_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_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); + EXPECT_EQ(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE); + EXPECT_NE(min_w, TDM_UT_INVALID_VALUE); + EXPECT_NE(min_h, TDM_UT_INVALID_VALUE); + EXPECT_NE(max_w, TDM_UT_INVALID_VALUE); + EXPECT_NE(max_h, TDM_UT_INVALID_VALUE); + EXPECT_NE(preferred_align, TDM_UT_INVALID_VALUE); } } } @@ -705,18 +705,18 @@ TEST_P(TDMOutput, OutputGetCursorAvailableSizeNullObject) int major = TDM_UT_INVALID_VALUE; int minor = TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE); + EXPECT_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_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); + EXPECT_EQ(tdm_output_get_cursor_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(min_w, TDM_UT_INVALID_VALUE); + EXPECT_EQ(min_h, TDM_UT_INVALID_VALUE); + EXPECT_EQ(max_w, TDM_UT_INVALID_VALUE); + EXPECT_EQ(max_h, TDM_UT_INVALID_VALUE); + EXPECT_EQ(preferred_align, TDM_UT_INVALID_VALUE); } } } @@ -728,9 +728,9 @@ TEST_P(TDMOutput, OutputGetCursorAvailableSizeNullOther) int major = TDM_UT_INVALID_VALUE; int minor = TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE); + EXPECT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE); if (major > 1 || (major >= 1 && minor >= 5)) - ASSERT_EQ(tdm_output_get_cursor_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_cursor_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE); } TEST_P(TDMOutput, OutputGetCursorAvailableSizeNoMatchVersion) @@ -740,18 +740,18 @@ TEST_P(TDMOutput, OutputGetCursorAvailableSizeNoMatchVersion) int major = TDM_UT_INVALID_VALUE; int minor = TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE); + EXPECT_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_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); + EXPECT_EQ(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_BAD_REQUEST); + EXPECT_EQ(min_w, TDM_UT_INVALID_VALUE); + EXPECT_EQ(min_h, TDM_UT_INVALID_VALUE); + EXPECT_EQ(max_w, TDM_UT_INVALID_VALUE); + EXPECT_EQ(max_h, TDM_UT_INVALID_VALUE); + EXPECT_EQ(preferred_align, TDM_UT_INVALID_VALUE); } } } @@ -763,9 +763,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_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); + EXPECT_EQ(tdm_output_get_physical_size(outputs[o], &mmWidth, &mmHeight), TDM_ERROR_NONE); + EXPECT_NE(mmWidth, (unsigned int)TDM_UT_INVALID_VALUE); + EXPECT_NE(mmHeight, (unsigned int)TDM_UT_INVALID_VALUE); } } @@ -775,16 +775,16 @@ TEST_P(TDMOutput, OutputGetPhysicalSizeNullObject) unsigned int mmWidth = (unsigned int)TDM_UT_INVALID_VALUE; unsigned int 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); + EXPECT_EQ(tdm_output_get_physical_size(NULL, &mmWidth, &mmHeight), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(mmWidth, (unsigned int)TDM_UT_INVALID_VALUE); + EXPECT_EQ(mmHeight, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetPhysicalSizeNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_get_physical_size(outputs[0], NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_physical_size(outputs[0], NULL, NULL), TDM_ERROR_NONE); } TEST_P(TDMOutput, OutputGetSubpixel) @@ -793,8 +793,8 @@ TEST_P(TDMOutput, OutputGetSubpixel) for (int o = 0; o < output_count; o++) { unsigned int 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); + EXPECT_EQ(tdm_output_get_subpixel(outputs[o], &subpixel), TDM_ERROR_NONE); + EXPECT_NE(subpixel, (unsigned int)TDM_UT_INVALID_VALUE); } } @@ -803,15 +803,15 @@ TEST_P(TDMOutput, OutputGetSubpixelNullObject) TDM_UT_SKIP_FLAG(has_outputs); unsigned int 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); + EXPECT_EQ(tdm_output_get_subpixel(NULL, &subpixel), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(subpixel, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetSubpixelNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_get_subpixel(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_get_subpixel(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetPipe) @@ -820,8 +820,8 @@ TEST_P(TDMOutput, OutputGetPipe) for (int o = 0; o < output_count; o++) { unsigned int 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); + EXPECT_EQ(tdm_output_get_pipe(outputs[o], &pipe), TDM_ERROR_NONE); + EXPECT_NE(pipe, (unsigned int)TDM_UT_INVALID_VALUE); } } @@ -830,15 +830,15 @@ TEST_P(TDMOutput, OutputGetPipeNullObject) TDM_UT_SKIP_FLAG(has_outputs); unsigned int 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); + EXPECT_EQ(tdm_output_get_pipe(NULL, &pipe), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(pipe, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetPipeNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_get_pipe(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_get_pipe(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetPrimaryIndex) @@ -849,8 +849,8 @@ TEST_P(TDMOutput, OutputGetPrimaryIndex) int primary_index = TDM_UT_INVALID_VALUE; if (!tc_tdm_output_is_hwc_enable(outputs[o])) { - ASSERT_EQ(tdm_output_get_primary_index(outputs[o], &primary_index), TDM_ERROR_NONE); - ASSERT_NE(primary_index, TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_output_get_primary_index(outputs[o], &primary_index), TDM_ERROR_NONE); + EXPECT_NE(primary_index, TDM_UT_INVALID_VALUE); } else TDM_UT_SKIP_FLAG(0); } @@ -861,15 +861,15 @@ TEST_P(TDMOutput, OutputGetPrimaryIndexNullObject) TDM_UT_SKIP_FLAG(has_outputs); int 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); + EXPECT_EQ(tdm_output_get_primary_index(NULL, &primary_index), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(primary_index, TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetPrimaryIndexNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_get_primary_index(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_get_primary_index(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, DISABLED_OutputSetProperty) @@ -880,7 +880,7 @@ TEST_P(TDMOutput, OutputSetPropertyNullObject) { tdm_value value = {.s32 = 0}; - ASSERT_EQ(tdm_output_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetProperty) @@ -890,15 +890,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_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE); - ASSERT_GE(count, 0); + EXPECT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE); + EXPECT_GE(count, 0); if (count > 0) { - ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE); + EXPECT_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_EQ(tdm_output_get_property(outputs[o], props[i].id, &value), TDM_ERROR_NONE); - ASSERT_NE(value.s32, TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_output_get_property(outputs[o], props[i].id, &value), TDM_ERROR_NONE); + EXPECT_NE(value.s32, TDM_UT_INVALID_VALUE); } } } @@ -909,15 +909,15 @@ TEST_P(TDMOutput, OutputGetPropertyNullObject) TDM_UT_SKIP_FLAG(has_outputs); tdm_value 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); + EXPECT_EQ(tdm_output_get_property(NULL, 0, &value), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(value.s32, TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetPropertyNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_get_property(outputs[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_get_property(outputs[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER); } static void @@ -936,14 +936,14 @@ TEST_P(TDMOutput, OutputAddChangeHandler) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); done1 = false; - ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_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); + EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(done1, true); } } @@ -951,22 +951,22 @@ TEST_P(TDMOutput, OutputAddChangeHandlerTwice) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_BAD_REQUEST); + EXPECT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_BAD_REQUEST); } TEST_P(TDMOutput, OutputAddChangeHandlerNullObject) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_add_change_handler(NULL, _tc_tdm_output_change_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_add_change_handler(NULL, _tc_tdm_output_change_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputAddChangeHandlerNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_add_change_handler(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_add_change_handler(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputRemoveChangeHandler) @@ -975,7 +975,7 @@ TEST_P(TDMOutput, OutputRemoveChangeHandler) for (int o = 0; o < output_count; o++) { for (int t = 0; t < 10; t++) { - ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE); tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL); } } @@ -989,14 +989,14 @@ TEST_P(TDMOutput, OutputRemoveChangeHandlerDifferentData) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); done1 = false; - ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE); tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL); - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - ASSERT_EQ(done1, true); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(done1, true); } } @@ -1017,22 +1017,22 @@ TEST_P(TDMOutput, OutputRemoveChangeHandlerInHandler) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); done1 = false; - ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_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); + EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb2, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(done1, true); done2 = false; - ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_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); + EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done2), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + EXPECT_EQ(done2, true); done3 = false; - ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_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); + EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb2, &done3), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(done3, true); } } @@ -1060,12 +1060,12 @@ TEST_P(TDMOutput, OutputSetMode) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE); - ASSERT_NE(modes, NULL); - ASSERT_GT(count, 0); + EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE); + EXPECT_NE(modes, NULL); + EXPECT_GT(count, 0); for (int m = 0; m < count; m++) - ASSERT_EQ(tdm_output_set_mode(outputs[o], modes + m), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_mode(outputs[o], modes + m), TDM_ERROR_NONE); } } @@ -1074,7 +1074,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_EQ(tdm_output_set_mode(NULL, mode), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_set_mode(NULL, mode), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputSetModeNullOther) @@ -1085,7 +1085,7 @@ TEST_P(TDMOutput, OutputSetModeNullOther) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tdm_output_set_mode(outputs[o], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_set_mode(outputs[o], NULL), TDM_ERROR_INVALID_PARAMETER); } } @@ -1100,15 +1100,15 @@ TEST_P(TDMOutput, OutputGetMode) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE); - ASSERT_NE(modes, NULL); - ASSERT_GT(count, 0); + EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE); + EXPECT_NE(modes, NULL); + EXPECT_GT(count, 0); for (int m = 0; m < count; m++) { const tdm_output_mode *current_mode; - 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); + EXPECT_EQ(tdm_output_set_mode(outputs[o], modes + m), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_mode(outputs[o], ¤t_mode), TDM_ERROR_NONE); + EXPECT_EQ(current_mode, modes + m); } } } @@ -1118,15 +1118,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_EQ(tdm_output_get_mode(NULL, ¤t_mode), TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(current_mode, (const tdm_output_mode *)TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_output_get_mode(NULL, ¤t_mode), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(current_mode, (const tdm_output_mode *)TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetModeNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_get_mode(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_get_mode(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputGetModeNoSet) @@ -1135,8 +1135,8 @@ TEST_P(TDMOutput, OutputGetModeNoSet) for (int o = 0; o < output_count; o++) { const tdm_output_mode *mode; - ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); - ASSERT_EQ(mode, NULL); + EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); + EXPECT_EQ(mode, NULL); } } @@ -1148,14 +1148,14 @@ TEST_P(TDMOutput, OutputSetDpms) if (!tc_tdm_output_is_connected(outputs[o])) continue; - 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); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); if (tc_tdm_output_is_aod_enable(outputs[o])) { - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE); } else { - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST); } } } @@ -1164,15 +1164,15 @@ TEST_P(TDMOutput, OutputSetDpmsNullObject) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_set_dpms(NULL, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_INVALID_PARAMETER); + EXPECT_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_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); + EXPECT_EQ(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)-1), TDM_ERROR_BAD_REQUEST); + EXPECT_EQ(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)INT_MAX), TDM_ERROR_BAD_REQUEST); } TEST_P(TDMOutput, OutputSetDpmsAsync) @@ -1186,11 +1186,11 @@ TEST_P(TDMOutput, OutputSetDpmsAsync) continue; done1 = false; - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_set_dpms_async(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms_async(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); while (!done1) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1); } } @@ -1205,28 +1205,28 @@ TEST_P(TDMOutput, OutputGetDpms) if (!tc_tdm_output_is_connected(outputs[o])) continue; - 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); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE); + EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_OFF); - 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); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE); + EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_STANDBY); - 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); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE); + EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_SUSPEND); - 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); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE); + EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_ON); if (tc_tdm_output_is_aod_enable(outputs[o])) { - 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); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE); + EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_AOD); } else { - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST); } } } @@ -1236,15 +1236,15 @@ TEST_P(TDMOutput, OutputGetDpmsNullObject) TDM_UT_SKIP_FLAG(has_outputs); tdm_output_dpms 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); + EXPECT_EQ(tdm_output_get_dpms(NULL, &dpms_value), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(dpms_value, (tdm_output_dpms)TDM_UT_INVALID_VALUE); } TEST_P(TDMOutput, OutputGetDpmsNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_get_dpms(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_get_dpms(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputWaitVblank) @@ -1255,7 +1255,7 @@ TEST_P(TDMOutput, OutputWaitVblank) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); for (int t = 0; t < 10; t++) { double start, end, interval; @@ -1264,13 +1264,13 @@ TEST_P(TDMOutput, OutputWaitVblank) done1 = false; start = tdm_helper_get_time(); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); while (!done1) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_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_LT((end - start), (interval + interval)); + EXPECT_LT((end - start), (interval + interval)); } } } @@ -1279,7 +1279,7 @@ TEST_P(TDMOutput, OutputWaitVblankNullObject) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_wait_vblank(NULL, 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_wait_vblank(NULL, 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputWaitVblankNullOther) @@ -1290,9 +1290,9 @@ TEST_P(TDMOutput, OutputWaitVblankNullOther) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, NULL, NULL), TDM_ERROR_NONE); } } @@ -1304,14 +1304,14 @@ TEST_P(TDMOutput, OutputWaitVblankTimeout) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_NONE); usleep(1100000); - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); - ASSERT_GT(tdm_helper_output_vblank_timer_expired(outputs[o]), 0); + EXPECT_GT(tdm_helper_output_vblank_timer_expired(outputs[o]), 0); } } @@ -1319,7 +1319,7 @@ TEST_P(TDMOutput, OutputWaitVblankInterval0) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_wait_vblank(outputs[0], 0, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_wait_vblank(outputs[0], 0, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputWaitVblankInterval) @@ -1330,7 +1330,7 @@ TEST_P(TDMOutput, OutputWaitVblankInterval) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); /* start from 1 */ for (int t = 1; t < 10; t++) { @@ -1340,14 +1340,14 @@ TEST_P(TDMOutput, OutputWaitVblankInterval) done1 = false; start = tdm_helper_get_time(); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); while (!done1) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_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_GT((end - start), (interval * (t - 1))); - ASSERT_LT((end - start), (interval * t + interval)); + EXPECT_GT((end - start), (interval * (t - 1))); + EXPECT_LT((end - start), (interval * t + interval)); } } } @@ -1360,7 +1360,7 @@ TEST_P(TDMOutput, OutputWaitVblankFewTimesInOneVblank) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); /* start from 1 */ for (int t = 1; t < 10; t++) { @@ -1369,18 +1369,18 @@ TEST_P(TDMOutput, OutputWaitVblankFewTimesInOneVblank) interval = tc_tdm_output_get_vblank_interval_time(outputs[o]); done1 = done2 = done3 = false; - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done1 || !done2 || !done3) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_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_GT((end - start), (interval * (t - 1))); - ASSERT_LT((end - start), (interval * t + interval)); + EXPECT_GT((end - start), (interval * (t - 1))); + EXPECT_LT((end - start), (interval * t + interval)); } } } @@ -1393,16 +1393,16 @@ TEST_P(TDMOutput, OutputWaitVblankBeforeDpmsOff) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], false), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], false), true); for (int t = 0; t < 10; t++) { bool done = false; - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done), TDM_ERROR_NONE); if (t == 9) - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1415,17 +1415,17 @@ TEST_P(TDMOutput, OutputRemoveVblankHandler) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); /* start from 1 */ for (int t = 1; t < 10; t++) { done1 = done2 = done3 = false; - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); tdm_output_remove_vblank_handler(outputs[o], _tc_tdm_output_done_cb, &done2); while (!done1 || done2 || !done3) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1443,12 +1443,12 @@ TEST_P(TDMOutput, OutputRemoveVblankHandlerDifferentData) /* start from 1 */ for (int t = 1; t < 10; t++) { done1 = done2 = done3 = false; - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); tdm_output_remove_vblank_handler(outputs[o], _tc_tdm_output_done_cb, NULL); while (!done1 || !done2 || !done3) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1472,16 +1472,16 @@ TEST_P(TDMOutput, OutputRemoveVblankHandlerInHandler) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); /* start from 1 */ for (int t = 1; t < 10; t++) { done1 = done2 = done3 = false; - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); while (!done1 || !done2 || !done3) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1498,7 +1498,7 @@ TEST_P(TDMOutput, OutputCommit) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); for (int t = 0; t < 10; t++) { double start, end, interval; @@ -1508,13 +1508,13 @@ TEST_P(TDMOutput, OutputCommit) done1 = false; start = tdm_helper_get_time(); if (!tc_tdm_output_is_hwc_enable(outputs[o])) { - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); while (!done1) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_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_LT((end - start), (interval + interval)); + EXPECT_LT((end - start), (interval + interval)); } else TDM_UT_SKIP_FLAG(0); } @@ -1525,7 +1525,7 @@ TEST_P(TDMOutput, OutputCommitNullObject) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_commit(NULL, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_output_commit(NULL, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputCommitNullOther) @@ -1540,9 +1540,9 @@ TEST_P(TDMOutput, OutputCommitNullOther) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); if (!tc_tdm_output_is_hwc_enable(outputs[o])) - ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); else TDM_UT_SKIP_FLAG(0); } @@ -1560,12 +1560,12 @@ TEST_P(TDMOutput, OutputCommitDpmsSuspend) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE); if (!tc_tdm_output_is_hwc_enable(outputs[o])) - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF); else TDM_UT_SKIP_FLAG(0); } @@ -1583,12 +1583,12 @@ TEST_P(TDMOutput, OutputCommitDpmsOff) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); if (!tc_tdm_output_is_hwc_enable(outputs[o])) - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF); else TDM_UT_SKIP_FLAG(0); } @@ -1609,15 +1609,15 @@ TEST_P(TDMOutput, OutputCommitDpmsAOD) if (!tc_tdm_output_is_aod_enable(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); - ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE); for (int t = 0; t < 10; t++) { done1 = false; - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); while (!done1) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1634,24 +1634,24 @@ TEST_P(TDMOutput, OutputCommitAfterLayerCommit) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); if (!tc_tdm_output_is_hwc_enable(outputs[o])) { - ASSERT_EQ(tdm_output_get_primary_index(outputs[o], &index), TDM_ERROR_NONE); - ASSERT_NE(index, TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_output_get_primary_index(outputs[o], &index), TDM_ERROR_NONE); + EXPECT_NE(index, TDM_UT_INVALID_VALUE); } else TDM_UT_SKIP_FLAG(0); layer = tdm_output_get_layer(outputs[o], index, &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(layer, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(layer, NULL); - ASSERT_EQ(tdm_layer_commit(layer, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_layer_commit(layer, NULL, NULL), TDM_ERROR_NONE); if (!tdm_helper_output_commit_per_vblank_enabled(outputs[o])) - ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); else - ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_BAD_REQUEST); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_BAD_REQUEST); } } @@ -1662,7 +1662,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_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_BAD_REQUEST); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_BAD_REQUEST); } } @@ -1678,16 +1678,16 @@ TEST_P(TDMOutput, OutputCommitFewTimesInOneVblank) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); for (int t = 0; t < 10; t++) { if (!tc_tdm_output_is_hwc_enable(outputs[o])) { done1 = done2 = done3 = false; - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); while (!done1 || !done2 || !done3) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } else TDM_UT_SKIP_FLAG(0); } @@ -1712,17 +1712,17 @@ TEST_P(TDMOutput, OutputRemoveCommitHandler) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); for (int t = 0; t < 10; t++) { if (!tc_tdm_output_is_hwc_enable(outputs[o])) { done1 = done2 = done3 = false; - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); tdm_output_remove_commit_handler(outputs[o], _tc_tdm_output_done_cb, &done2); while (!done1 || done2 || !done3) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } else TDM_UT_SKIP_FLAG(0); } @@ -1741,17 +1741,17 @@ TEST_P(TDMOutput, OutputRemoveCommitHandlerDifferentData) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); for (int t = 0; t < 10; t++) { if (!tc_tdm_output_is_hwc_enable(outputs[o])) { done1 = done2 = done3 = false; - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); tdm_output_remove_commit_handler(outputs[o], _tc_tdm_output_done_cb, NULL); while (!done1 || !done2 || !done3) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } else TDM_UT_SKIP_FLAG(0); } @@ -1770,16 +1770,16 @@ TEST_P(TDMOutput, OutputRemoveCommitHandlerInHandler) if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); + EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); for (int t = 0; t < 10; t++) { if (!tc_tdm_output_is_hwc_enable(outputs[o])) { done1 = done2 = done3 = false; - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done3), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done2), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done3), TDM_ERROR_NONE); while (!done1 || !done2 || !done3) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } else TDM_UT_SKIP_FLAG(0); } diff --git a/haltests/src/tc_tdm_vblank.cpp b/haltests/src/tc_tdm_vblank.cpp index 07e97ba..119dadc 100644 --- a/haltests/src/tc_tdm_vblank.cpp +++ b/haltests/src/tc_tdm_vblank.cpp @@ -184,8 +184,8 @@ TEST_P(TDMVblank, DISABLED_VblankSetClientVblankFps) TEST_P(TDMVblank, VblankSetClientVblankFpsNullObject) { - 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); + EXPECT_EQ(tdm_vblank_set_client_vblank_fps(0, NULL, 60), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_vblank_set_client_vblank_fps(123, NULL, 0), TDM_ERROR_INVALID_PARAMETER); } /* tdm_vblank_set_client_vblank_fps */ @@ -196,8 +196,8 @@ TEST_P(TDMVblank, DISABLED_VblankSetClientIgnoreGlobalFps) TEST_P(TDMVblank, VblankSetClientIgnoreGlobalFpsNullObject) { - 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); + EXPECT_EQ(tdm_vblank_set_client_ignore_global_fps(0, NULL, 0), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_vblank_set_client_ignore_global_fps(0, NULL, 1), TDM_ERROR_INVALID_PARAMETER); } /* tdm_vblank_create() */ @@ -208,8 +208,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_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(vblank, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(vblank, NULL); tdm_vblank_destroy(vblank); } @@ -222,8 +222,8 @@ TEST_P(TDMVblank, VblankCreateNullDpy) tdm_error ret; tdm_vblank *vblank = tdm_vblank_create(NULL, outputs[0], &ret); - ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(vblank, NULL); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vblank, NULL); } TEST_P(TDMVblank, VblankCreateNullOutput) @@ -231,8 +231,8 @@ TEST_P(TDMVblank, VblankCreateNullOutput) tdm_error ret; tdm_vblank *vblank = tdm_vblank_create(dpy, NULL, &ret); - ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(vblank, NULL); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vblank, NULL); } TEST_P(TDMVblank, VblankCreateNullOther) @@ -240,7 +240,7 @@ TEST_P(TDMVblank, VblankCreateNullOther) TDM_UT_SKIP_FLAG(has_outputs); tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[0], NULL); - ASSERT_NE(vblank, NULL); + EXPECT_NE(vblank, NULL); tdm_vblank_destroy(vblank); } @@ -264,7 +264,7 @@ TEST_P(TDMVblank, VblankAddCreateHandler) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE); for (int o = 0; o < output_count; o++) { tdm_error ret; @@ -272,9 +272,9 @@ TEST_P(TDMVblank, VblankAddCreateHandler) done = false; tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(vblank, NULL); - ASSERT_EQ(done, true); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(vblank, NULL); + EXPECT_EQ(done, true); tdm_vblank_destroy(vblank); } @@ -284,22 +284,22 @@ TEST_P(TDMVblank, VblankAddCreateHandlerTwice) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_NONE); - ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_BAD_REQUEST); + EXPECT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_BAD_REQUEST); } TEST_P(TDMVblank, VblankAddCreateHandlerNullObject) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_vblank_add_create_handler(NULL, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_vblank_add_create_handler(NULL, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankAddCreateHandlerNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_vblank_add_create_handler(dpy, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_vblank_add_create_handler(dpy, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } /* tdm_vblank_remove_create_handler */ @@ -307,7 +307,7 @@ TEST_P(TDMVblank, VblankRemoveCreateHandler) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE); tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this); for (int o = 0; o < output_count; o++) { @@ -316,9 +316,9 @@ TEST_P(TDMVblank, VblankRemoveCreateHandler) done = false; tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(vblank, NULL); - ASSERT_EQ(done, false); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(vblank, NULL); + EXPECT_EQ(done, false); tdm_vblank_destroy(vblank); } @@ -328,7 +328,7 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerFewTimes) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE); tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this); tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this); @@ -340,9 +340,9 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerFewTimes) done = false; tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(vblank, NULL); - ASSERT_EQ(done, false); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(vblank, NULL); + EXPECT_EQ(done, false); tdm_vblank_destroy(vblank); } @@ -352,7 +352,7 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerDifferentData) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE); tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL); @@ -362,9 +362,9 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerDifferentData) done = false; tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(vblank, NULL); - ASSERT_EQ(done, true); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(vblank, NULL); + EXPECT_EQ(done, true); tdm_vblank_destroy(vblank); } @@ -382,7 +382,7 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerInHandler) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb2, this), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb2, this), TDM_ERROR_NONE); for (int o = 0; o < output_count; o++) { tdm_error ret; @@ -390,12 +390,12 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerInHandler) done = false; tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret); - ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_NE(vblank, NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(vblank, NULL); if (o == 0) - ASSERT_EQ(done, true); + EXPECT_EQ(done, true); else - ASSERT_EQ(done, false); + EXPECT_EQ(done, false); tdm_vblank_destroy(vblank); } @@ -420,29 +420,29 @@ TEST_P(TDMVblank, VblankGetOutput) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { tdm_error ret; - ASSERT_NE(tdm_vblank_get_output(vblanks[v], &ret), NULL); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(tdm_vblank_get_output(vblanks[v], &ret), NULL); + EXPECT_EQ(ret, TDM_ERROR_NONE); } } TEST_P(TDMVblank, VblankGetOutputNullObject) { tdm_error ret; - ASSERT_EQ(tdm_vblank_get_output(NULL, &ret), NULL); - ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_vblank_get_output(NULL, &ret), NULL); + EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankGetOutputNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); - ASSERT_NE(tdm_vblank_get_output(vblanks[0], NULL), NULL); + EXPECT_NE(tdm_vblank_get_output(vblanks[0], NULL), NULL); } /* tdm_vblank_get_client_pid() */ @@ -450,30 +450,30 @@ TEST_P(TDMVblank, VblankGetClientPid) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { pid_t pid = (pid_t)TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_vblank_get_client_pid(vblanks[v], &pid), TDM_ERROR_NONE); + EXPECT_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_EQ(pid, 0); + EXPECT_EQ(pid, 0); } } TEST_P(TDMVblank, VblankGetClientPidNullObject) { pid_t 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); + EXPECT_EQ(tdm_vblank_get_client_pid(NULL, &pid), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(pid, (pid_t)TDM_UT_INVALID_VALUE); } TEST_P(TDMVblank, VblankGetClientPidNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); - ASSERT_EQ(tdm_vblank_get_client_pid(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_vblank_get_client_pid(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER); } /* tdm_vblank_set_name() */ @@ -481,25 +481,25 @@ TEST_P(TDMVblank, VblankSetName) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) - ASSERT_EQ(tdm_vblank_set_name(vblanks[v], TDM_UT_VBLANK_NAME), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_set_name(vblanks[v], TDM_UT_VBLANK_NAME), TDM_ERROR_NONE); } TEST_P(TDMVblank, VblankSetNameNullObject) { - ASSERT_EQ(tdm_vblank_set_name(NULL, TDM_UT_VBLANK_NAME), TDM_ERROR_INVALID_PARAMETER); + EXPECT_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_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) - ASSERT_EQ(tdm_vblank_set_name(vblanks[v], NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_set_name(vblanks[v], NULL), TDM_ERROR_NONE); } /* tdm_vblank_get_name() */ @@ -507,42 +507,42 @@ TEST_P(TDMVblank, VblankGetName) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { const char *name = (const char *)TDM_UT_INVALID_VALUE; - 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); + EXPECT_EQ(tdm_vblank_set_name(vblanks[v], TDM_UT_VBLANK_NAME), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_get_name(vblanks[v], &name), TDM_ERROR_NONE); + EXPECT_STREQ(name, TDM_UT_VBLANK_NAME); } } TEST_P(TDMVblank, VblankGetNameNullObject) { const char *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); + EXPECT_EQ(tdm_vblank_get_name(NULL, &name), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(name, (const char *)TDM_UT_INVALID_VALUE); } TEST_P(TDMVblank, VblankGetNameNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); - ASSERT_EQ(tdm_vblank_get_name(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_vblank_get_name(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankGetNameNoSet) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { const char *name = (const char *)TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_vblank_get_name(vblanks[v], &name), TDM_ERROR_NONE); - ASSERT_STREQ(name, TDM_VBLANK_DEFAULT_NAME); + EXPECT_EQ(tdm_vblank_get_name(vblanks[v], &name), TDM_ERROR_NONE); + EXPECT_STREQ(name, TDM_VBLANK_DEFAULT_NAME); } } @@ -551,26 +551,26 @@ TEST_P(TDMVblank, VblankSetFps) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) - ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE); } TEST_P(TDMVblank, VblankSetFpsNullObject) { - ASSERT_EQ(tdm_vblank_set_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_vblank_set_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankSetFpsTwice) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { - ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE); - ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE); } } @@ -579,26 +579,26 @@ TEST_P(TDMVblank, VblankSetFixedFps) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) - ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE); } TEST_P(TDMVblank, VblankSetFixedFpsNullObject) { - ASSERT_EQ(tdm_vblank_set_fixed_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_vblank_set_fixed_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankSetFixedFpsTwice) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { - 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); + EXPECT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE); } } @@ -607,38 +607,38 @@ TEST_P(TDMVblank, VblankGetFps) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; - 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); + EXPECT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); + EXPECT_EQ(fps, 60); } } TEST_P(TDMVblank, VblankGetFpsNullObject) { unsigned int 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); + EXPECT_EQ(tdm_vblank_get_fps(NULL, &fps), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(fps, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMVblank, VblankGetFpsNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); - ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_vblank_get_fps(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankGetFpsNoSet) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; @@ -648,17 +648,17 @@ TEST_P(TDMVblank, VblankGetFpsNoSet) if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; - ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); - ASSERT_TRUE(fps != 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); + EXPECT_TRUE(fps != 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret); - ASSERT_NE(output, NULL); - ASSERT_EQ(ret, TDM_ERROR_NONE); + EXPECT_NE(output, NULL); + EXPECT_EQ(ret, 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); + EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); + EXPECT_TRUE(mode != NULL && mode != (const tdm_output_mode *)TDM_UT_INVALID_VALUE); - ASSERT_EQ(fps, mode->vrefresh); + EXPECT_EQ(fps, mode->vrefresh); } } @@ -666,54 +666,54 @@ TEST_P(TDMVblank, VblankGetFpsAfterSetFixedFps) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; - 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); + EXPECT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); + EXPECT_EQ(fps, 60); - 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); + EXPECT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); + EXPECT_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_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); + EXPECT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); + EXPECT_EQ(fps, 10); } } /* tdm_vblank_ignore_global_fps() */ TEST_P(TDMVblank, VblankIgnoreGlobalFpsNullObject) { - ASSERT_EQ(tdm_vblank_ignore_global_fps(NULL, 1), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_vblank_ignore_global_fps(NULL, 1), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankIgnoreGlobalFpsSet) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) - ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE); } TEST_P(TDMVblank, VblankIgnoreGlobalFpsSetTwice) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { - 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); + EXPECT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE); } } @@ -721,21 +721,21 @@ TEST_P(TDMVblank, VblankIgnoreGlobalFpsUnset) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) - ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE); } TEST_P(TDMVblank, VblankIgnoreGlobalFpsUnsetTwice) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { - 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); + EXPECT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE); } } @@ -744,26 +744,26 @@ TEST_P(TDMVblank, VblankSetOffset) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) - ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE); } TEST_P(TDMVblank, VblankSetOffsetNullObject) { - ASSERT_EQ(tdm_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankSetOffsetTwice) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { - ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE); - ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE); } } @@ -772,42 +772,42 @@ TEST_P(TDMVblank, VblankGetOffset) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { int offset = TDM_UT_INVALID_VALUE; - 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); + EXPECT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_get_offset(vblanks[v], &offset), TDM_ERROR_NONE); + EXPECT_EQ(offset, 10); } } TEST_P(TDMVblank, VblankGetOffsetNullObject) { int offset = TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_vblank_get_offset(NULL, &offset), TDM_ERROR_INVALID_PARAMETER); - ASSERT_EQ(offset, TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_vblank_get_offset(NULL, &offset), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(offset, TDM_UT_INVALID_VALUE); } TEST_P(TDMVblank, VblankGetOffsetNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); - ASSERT_EQ(tdm_vblank_get_offset(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_vblank_get_offset(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankGetOffsetNoSet) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { int offset = TDM_UT_INVALID_VALUE; - ASSERT_EQ(tdm_vblank_get_offset(vblanks[v], &offset), TDM_ERROR_NONE); - ASSERT_EQ(offset, 0); + EXPECT_EQ(tdm_vblank_get_offset(vblanks[v], &offset), TDM_ERROR_NONE); + EXPECT_EQ(offset, 0); } } @@ -816,26 +816,26 @@ TEST_P(TDMVblank, VblankSetEnableFake) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) - ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE); } TEST_P(TDMVblank, VblankSetEnableFakeNullObject) { - ASSERT_EQ(tdm_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankSetEnableFakeTwice) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { - 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); + EXPECT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE); } } @@ -844,46 +844,46 @@ TEST_P(TDMVblank, VblankGetEnableFake) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int enable_fake; - 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); + EXPECT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE); + EXPECT_EQ(enable_fake, 1); - 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); + EXPECT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 0), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE); + EXPECT_EQ(enable_fake, 0); } } TEST_P(TDMVblank, VblankGetEnableFakeNullObject) { unsigned int 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); + EXPECT_EQ(tdm_vblank_get_enable_fake(NULL, &enable_fake), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(enable_fake, (unsigned int)TDM_UT_INVALID_VALUE); } TEST_P(TDMVblank, VblankGetEnableFakeNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); - ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_vblank_get_enable_fake(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankGetEnableFakeNoSet) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int enable_fake; - ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE); - ASSERT_EQ(enable_fake, 0); + EXPECT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE); + EXPECT_EQ(enable_fake, 0); } } @@ -900,8 +900,8 @@ TEST_P(TDMVblank, VblankWait) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; @@ -910,21 +910,21 @@ TEST_P(TDMVblank, VblankWait) if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; - ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); - ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); + EXPECT_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; start = tdm_helper_get_time(); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_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_LT((end - start), (interval + interval)); + EXPECT_LT((end - start), (interval + interval)); } } } @@ -933,8 +933,8 @@ TEST_P(TDMVblank, VblankWaitFewTime) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; @@ -943,8 +943,8 @@ TEST_P(TDMVblank, VblankWaitFewTime) if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; - ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); - ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); + EXPECT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); interval = 1.0 / (double)fps; for (int t = 0; t < 10; t++) { @@ -952,18 +952,18 @@ TEST_P(TDMVblank, VblankWaitFewTime) cur_seq = seq1 = seq2 = 0; start = tdm_helper_get_time(); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &seq1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &seq2), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &seq1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &seq2), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); - ASSERT_NE(seq1, 0); - ASSERT_NE(seq2, 0); + EXPECT_NE(seq1, 0); + EXPECT_NE(seq2, 0); /* "+ interval" consider the delay of socket communication between kernel and platform */ - ASSERT_LT((end - start), (interval + interval)); + EXPECT_LT((end - start), (interval + interval)); } } } @@ -972,18 +972,18 @@ TEST_P(TDMVblank, VblankWaitInterval0) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_EQ(TestCreateVblanks(), true); - ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, _tc_tdm_vblank_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, _tc_tdm_vblank_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankWaitInterval) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; @@ -992,8 +992,8 @@ TEST_P(TDMVblank, VblankWaitInterval) if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; - ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); - ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); + EXPECT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); interval = 1.0 / (double)fps; /* start from 1 */ @@ -1001,14 +1001,14 @@ TEST_P(TDMVblank, VblankWaitInterval) unsigned int cur_seq = 0; start = tdm_helper_get_time(); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, t, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, t, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_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_GT((end - start), interval * (t - 1)); - ASSERT_LT((end - start), interval * t + interval); + EXPECT_GT((end - start), interval * (t - 1)); + EXPECT_LT((end - start), interval * t + interval); } } } @@ -1017,8 +1017,8 @@ TEST_P(TDMVblank, VblankWaitSeq) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; @@ -1027,25 +1027,25 @@ TEST_P(TDMVblank, VblankWaitSeq) if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; - ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); - ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); + EXPECT_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_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); start = tdm_helper_get_time(); - ASSERT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + 1, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + 1, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE); while (temp == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_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_LT((end - start), (interval + interval)); + EXPECT_LT((end - start), (interval + interval)); } } } @@ -1054,8 +1054,8 @@ TEST_P(TDMVblank, VblankWaitSeqInterval) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; @@ -1064,27 +1064,27 @@ TEST_P(TDMVblank, VblankWaitSeqInterval) if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; - ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); - ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); + EXPECT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); interval = 1.0 / (double)fps; /* start from 1 */ for (int t = 1; t < 10; t++) { unsigned int cur_seq = 0, temp = 0; - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); start = tdm_helper_get_time(); - ASSERT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + t, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + t, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE); while (temp == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_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_GT((end - start), (interval * (t - 1))); - ASSERT_LT((end - start), (interval * t + interval)); + EXPECT_GT((end - start), (interval * (t - 1))); + EXPECT_LT((end - start), (interval * t + interval)); } } } @@ -1095,36 +1095,36 @@ TEST_P(TDMVblank, VblankWaitNullObject) unsigned int cur_seq = 0; - ASSERT_EQ(tdm_vblank_wait(NULL, 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_INVALID_PARAMETER); + EXPECT_EQ(tdm_vblank_wait(NULL, 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankWaitNullOther) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestCreateVblanks(), true); - ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); + EXPECT_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_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_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_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); if (!tc_tdm_output_is_connected(output)) continue; - ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_DPMS_OFF); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_DPMS_OFF); } } @@ -1132,24 +1132,24 @@ TEST_P(TDMVblank, VblankWaitBeforeDpmsOff) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_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_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); if (!tc_tdm_output_is_connected(output)) continue; - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); while (temp == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } @@ -1157,13 +1157,13 @@ TEST_P(TDMVblank, VblankWaitSetEnableFakeDpmsOff) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_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_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; @@ -1171,11 +1171,11 @@ TEST_P(TDMVblank, VblankWaitSetEnableFakeDpmsOff) if (!tc_tdm_output_is_connected(output)) continue; - ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); + EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); - ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_NONE); } } @@ -1183,18 +1183,18 @@ TEST_P(TDMVblank, VblankWaitDisconnectedOutput) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_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_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); if (tc_tdm_output_is_connected(output)) continue; - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_OUTPUT_DISCONNECTED); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_OUTPUT_DISCONNECTED); } } @@ -1202,8 +1202,8 @@ TEST_P(TDMVblank, VblankWaitSetOffset) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; @@ -1212,24 +1212,24 @@ TEST_P(TDMVblank, VblankWaitSetOffset) if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; - ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 100), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_set_offset(vblanks[v], 100), 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); + EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); + EXPECT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); interval = 1.0 / (double)fps; for (int t = 0; t < 3; t++) { unsigned int cur_seq = 0; start = tdm_helper_get_time(); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_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_GT((end - start), (0.1)); - ASSERT_LT((end - start), (interval + interval + 0.1)); + EXPECT_GT((end - start), (0.1)); + EXPECT_LT((end - start), (interval + interval + 0.1)); } } } @@ -1238,8 +1238,8 @@ TEST_P(TDMVblank, VblankWaitSetFps) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; @@ -1248,26 +1248,26 @@ TEST_P(TDMVblank, VblankWaitSetFps) if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; - ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); - ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); + EXPECT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); vrefresh_interval = 1.0 / (double)fps; fps /= 2; - ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], fps), TDM_ERROR_NONE); + EXPECT_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_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_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_GT((end - start), (interval - vrefresh_interval)); - ASSERT_LT((end - start), (interval + vrefresh_interval)); + EXPECT_GT((end - start), (interval - vrefresh_interval)); + EXPECT_LT((end - start), (interval + vrefresh_interval)); } } } @@ -1276,8 +1276,8 @@ TEST_P(TDMVblank, VblankWaitSetFixedFps) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_EQ(TestCreateVblanks(), true); for (int v = 0; v < vblank_count; v++) { unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; @@ -1286,27 +1286,27 @@ TEST_P(TDMVblank, VblankWaitSetFixedFps) if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; - ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); - ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); + EXPECT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE); interval = 1.0 / (double)fps; - ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], fps), TDM_ERROR_NONE); + EXPECT_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_EQ(tdm_vblank_set_fps(vblanks[v], fps), TDM_ERROR_NONE); + EXPECT_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_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_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_LT((end - start), (interval + interval)); + EXPECT_LT((end - start), (interval + interval)); } } } @@ -1321,19 +1321,19 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps) unsigned int global_fps = 5; double start, end, interval; - ASSERT_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks3(), true); - ASSERT_EQ(vblank_count, 3); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_EQ(TestCreateVblanks3(), true); + EXPECT_EQ(vblank_count, 3); if (!tc_tdm_vblank_is_avaiable(vblanks[0])) return; - ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE); - ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE); + EXPECT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE); + EXPECT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE); vrefresh_interval = 1.0 / (double)fps; for (int v = 0; v < 3; v++) { - ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)), TDM_ERROR_NONE); interval = 1.0 / (double)(10 * (v + 1)); } @@ -1342,57 +1342,57 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps) for (int v = 0; v < 3; v++) { cur_seq[v] = 0; - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); } start = tdm_helper_get_time(); while (cur_seq[2] == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_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_GT((end - start), (interval - vrefresh_interval)); - ASSERT_LT((end - start), (interval + vrefresh_interval)); + EXPECT_GT((end - start), (interval - vrefresh_interval)); + EXPECT_LT((end - start), (interval + vrefresh_interval)); - ASSERT_EQ(cur_seq[1], 0); - ASSERT_EQ(cur_seq[0], 0); + EXPECT_EQ(cur_seq[1], 0); + EXPECT_EQ(cur_seq[0], 0); while (cur_seq[1] == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); - ASSERT_EQ(cur_seq[0], 0); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(cur_seq[0], 0); while (cur_seq[0] == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_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_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); } while (cur_seq[2] == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); - ASSERT_EQ(cur_seq[1], 0); - ASSERT_EQ(cur_seq[0], 0); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(cur_seq[1], 0); + EXPECT_EQ(cur_seq[0], 0); while (cur_seq[1] == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); - ASSERT_EQ(cur_seq[0], 0); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(cur_seq[0], 0); } TEST_P(TDMVblank, VblankWaitSetEnableFakeDisconnected) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_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_EQ(ret, TDM_ERROR_NONE); + EXPECT_EQ(ret, TDM_ERROR_NONE); if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; @@ -1400,9 +1400,9 @@ TEST_P(TDMVblank, VblankWaitSetEnableFakeDisconnected) if (tc_tdm_output_is_connected(output)) continue; - ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_DPMS_OFF); + EXPECT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_DPMS_OFF); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_NONE); } } @@ -1415,17 +1415,17 @@ TEST_P(TDMVblank, VblankWaitTimeout) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(TestPrepareOutput(), true); - ASSERT_EQ(TestCreateVblanks(), true); + EXPECT_EQ(TestPrepareOutput(), true); + EXPECT_EQ(TestCreateVblanks(), true); if (vblank_count > 0) { tdm_vblank *vblank = vblanks[0]; unsigned int cur_seq = 0; - ASSERT_EQ(tdm_vblank_wait(vblank, 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + EXPECT_EQ(tdm_vblank_wait(vblank, 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); usleep(1200000); while (cur_seq == 0) - ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } -- 2.7.4 From d4e76fcb0381ed8156fca82947126a0b250e2039 Mon Sep 17 00:00:00 2001 From: Junkyeong Kim Date: Mon, 8 Feb 2021 18:44:31 +0900 Subject: [PATCH 16/16] tc: erase assert Change-Id: I30f90d157ed25c898ff623661730d68947b534bd Signed-off-by: Junkyeong Kim --- haltests/src/tc_tdm_output.cpp | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/haltests/src/tc_tdm_output.cpp b/haltests/src/tc_tdm_output.cpp index 764d63e..193b2ce 100644 --- a/haltests/src/tc_tdm_output.cpp +++ b/haltests/src/tc_tdm_output.cpp @@ -330,9 +330,9 @@ tc_tdm_output_get_vblank_interval_time(tdm_output *output) const tdm_output_mode *mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE; tdm_error ret = tdm_output_get_mode(output, &mode); - assert(ret == TDM_ERROR_NONE); - assert(mode != NULL); - assert(mode->vrefresh > 0); + if (ret != TDM_ERROR_NONE) return -1; + if (mode == NULL) return -1; + if (mode->vrefresh == 0) return -1; return (double)1.0 / (double)mode->vrefresh; } @@ -1261,6 +1261,7 @@ TEST_P(TDMOutput, OutputWaitVblank) double start, end, interval; interval = tc_tdm_output_get_vblank_interval_time(outputs[o]); + EXPECT_NE(interval, -1); done1 = false; start = tdm_helper_get_time(); @@ -1337,6 +1338,7 @@ TEST_P(TDMOutput, OutputWaitVblankInterval) double start, end, interval; interval = tc_tdm_output_get_vblank_interval_time(outputs[o]); + EXPECT_NE(interval, -1); done1 = false; start = tdm_helper_get_time(); @@ -1367,6 +1369,7 @@ TEST_P(TDMOutput, OutputWaitVblankFewTimesInOneVblank) double start, end, interval; interval = tc_tdm_output_get_vblank_interval_time(outputs[o]); + EXPECT_NE(interval, -1); done1 = done2 = done3 = false; EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); @@ -1504,6 +1507,7 @@ TEST_P(TDMOutput, OutputCommit) double start, end, interval; interval = tc_tdm_output_get_vblank_interval_time(outputs[o]); + EXPECT_NE(interval, -1); done1 = false; start = tdm_helper_get_time(); -- 2.7.4