From 7120d721e9c87acbfc8ee174391bbda73cc11888 Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Sun, 7 Feb 2021 19:05:31 +0900 Subject: [PATCH] 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