haltests: use EXPECT intead of ASSERT

[platform/core/uifw/libtdm.git] / haltests / src / tc_tdm_backend_capture.cpp

diff --git a/haltests/src/tc_tdm_backend_capture.cpp b/haltests/src/tc_tdm_backend_capture.cpp
index 006430e..4b9f941 100644 (file)
--- 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);