change the utests to haltests

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

diff --git a/utests/src/ut_tdm_backend_capture.cpp b/haltests/src/tc_tdm_backend_capture.cpp
similarity index 91%
rename from utests/src/ut_tdm_backend_capture.cpp
rename to haltests/src/tc_tdm_backend_capture.cpp
index 8eca5d6..010153f 100644 (file)
--- a/utests/src/ut_tdm_backend_capture.cpp
+++ b/haltests/src/tc_tdm_backend_capture.cpp
@@ -28,7 +28,7 @@
  *
 **************************************************************************/
 
-#include "ut_tdm.h"
+#include "tc_tdm.h"
 
 /* LCOV_EXCL_START */
 class TDMBackendCapture : public TDMBackendDisplay
@@ -127,10 +127,10 @@ void TDMBackendCapture::SetUp(void)
        ASSERT_TRUE(preferred_align == -1 || preferred_align > 0);
 
        for (int o = 0; o < output_count; o++) {
-               if (!ut_tdm_output_is_connected(outputs[o]))
+               if (!tc_tdm_output_is_connected(outputs[o]))
                        continue;
 
-               ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+               ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
        }
 }
 
@@ -140,10 +140,10 @@ void TDMBackendCapture::TearDown(void)
                tdm_capture_destroy(capture);
 
        for (int o = 0; o < output_count; o++) {
-               if (!ut_tdm_output_is_connected(outputs[o]))
+               if (!tc_tdm_output_is_connected(outputs[o]))
                        continue;
 
-               ASSERT_EQ(ut_tdm_output_unset(dpy, outputs[o]), true);
+               ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
        }
 
        DestroyBuffers();
@@ -156,7 +156,7 @@ bool TDMBackendCapture::FindLayer(int output_idx, tbm_format fmt, tdm_pos *punch
        tdm_error ret;
        int count;
        int primary_zpos, zpos;
-       tdm_layer *primary = ut_tdm_output_get_primary_layer(outputs[output_idx]);
+       tdm_layer *primary = tc_tdm_output_get_primary_layer(outputs[output_idx]);
        TDM_UT_RETURN_FALSE_IF_FAIL(primary != NULL);
        TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_layer_count(outputs[output_idx], &count) == TDM_ERROR_NONE);
        TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_zpos(primary, &primary_zpos) == TDM_ERROR_NONE);
@@ -209,15 +209,15 @@ bool TDMBackendCapture::TestPrepareDefault(void)
        tdm_error ret;
 
        for (int o = 0; o < output_count; o++) {
-               if (!ut_tdm_output_is_connected(outputs[o]))
+               if (!tc_tdm_output_is_connected(outputs[o]))
                        continue;
 
                capture = tdm_output_create_capture(outputs[o], &ret);
                TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
                TDM_UT_RETURN_FALSE_IF_FAIL(capture != NULL);
 
-               TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[0], 0, false, 3, buffers) == true);
-               TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_capture_fill_info(outputs[o], buffers[0], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false, &info) == true);
+               TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[0], 0, false, 3, buffers) == true);
+               TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_capture_fill_info(outputs[o], buffers[0], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false, &info) == true);
                TDM_UT_RETURN_FALSE_IF_FAIL(tdm_capture_set_info(capture, &info) == TDM_ERROR_NONE);
 
                output = outputs[o];
@@ -259,8 +259,8 @@ bool TDMBackendCapture::TestPrepare(int output_idx, int w, int h, tbm_format fmt
                        flags |= TBM_BO_SCANOUT;
        }
 
-       TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_buffer_create(w, h, fmt, flags, false, 3, buffers) == true);
-       TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_capture_fill_info(outputs[output_idx], buffers[0], t, c, frequency, stretch, &info) == true);
+       TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_buffer_create(w, h, fmt, flags, false, 3, buffers) == true);
+       TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_capture_fill_info(outputs[output_idx], buffers[0], t, c, frequency, stretch, &info) == true);
        TDM_UT_RETURN_FALSE_IF_FAIL(tdm_capture_set_info(capture, &info) == TDM_ERROR_NONE);
 
        output = outputs[output_idx];
@@ -293,7 +293,7 @@ void TDMBackendCapture::ShowBuffer(int b, tdm_pos *pos)
        ASSERT_NE(output, NULL);
        ASSERT_NE(dst_layer, NULL);
 
-       ASSERT_EQ(ut_tdm_layer_set_buffer_with_pos(dst_layer, buffers[b], pos), true);
+       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);
 }
 
@@ -317,7 +317,7 @@ void TDMBackendCapture::DestroyBuffers(void)
 }
 
 static void
-_ut_tdm_capture_fit_rect(int src_w, int src_h, int dst_w, int dst_h, tdm_pos *fit)
+_tc_tdm_capture_fit_rect(int src_w, int src_h, int dst_w, int dst_h, tdm_pos *fit)
 {
        float rw, rh;
 
@@ -349,7 +349,7 @@ _ut_tdm_capture_fit_rect(int src_w, int src_h, int dst_w, int dst_h, tdm_pos *fi
 }
 
 bool
-ut_tdm_capture_fill_info(tdm_output *output, tbm_surface_h buffer, tdm_transform transform,
+tc_tdm_capture_fill_info(tdm_output *output, tbm_surface_h buffer, tdm_transform transform,
                                                 tdm_capture_type type, int frequency, bool stretch, tdm_info_capture *info)
 {
        int bw, bh;
@@ -376,7 +376,7 @@ ut_tdm_capture_fill_info(tdm_output *output, tbm_surface_h buffer, tdm_transform
                info->dst_config.pos.w = tbm_surface_get_width(buffer);
                info->dst_config.pos.h = tbm_surface_get_height(buffer);
        } else {
-               _ut_tdm_capture_fit_rect(mode->hdisplay, mode->vdisplay,
+               _tc_tdm_capture_fit_rect(mode->hdisplay, mode->vdisplay,
                                                                 tbm_surface_get_width(buffer), tbm_surface_get_height(buffer),
                                                                 &info->dst_config.pos);
        }
@@ -523,7 +523,7 @@ TEST_P(TDMBackendCapture, CaptureSetInfoNullOther)
 }
 
 static void
-_ut_tdm_capture_done_cb(tdm_capture *capture, tbm_surface_h buffer, void *user_data)
+_tc_tdm_capture_done_cb(tdm_capture *capture, tbm_surface_h buffer, void *user_data)
 {
        bool *done = (bool*)user_data;
        if (done)
@@ -537,7 +537,7 @@ TEST_P(TDMBackendCapture, CaptureSetDoneHandler)
 
        ASSERT_EQ(TestPrepareDefault(), true);
 
-       ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb, NULL), TDM_ERROR_NONE);
+       ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, NULL), TDM_ERROR_NONE);
 
        TestDone();
 }
@@ -547,7 +547,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, _ut_tdm_capture_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+       ASSERT_EQ(tdm_capture_set_done_handler(NULL, _tc_tdm_capture_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMBackendCapture, CaptureSetDoneHandlerNullOther)
@@ -569,7 +569,7 @@ TEST_P(TDMBackendCapture, CaptureAttach)
 
        for (int o = 0; o < output_count; o++) {
 
-               if (!ut_tdm_output_is_connected(outputs[o]))
+               if (!tc_tdm_output_is_connected(outputs[o]))
                        continue;
 
                for (int f = 0; f < format_count; f++) {
@@ -635,7 +635,7 @@ TEST_P(TDMBackendCapture, CaptureCommitDpmsOff)
 
        ASSERT_EQ(TestPrepareDefault(), true);
 
-       ASSERT_EQ(ut_tdm_output_unset(dpy, output), true);
+       ASSERT_EQ(tc_tdm_output_unset(dpy, output), true);
 
        ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
 
@@ -645,7 +645,7 @@ TEST_P(TDMBackendCapture, CaptureCommitDpmsOff)
 }
 
 static void
-_ut_tdm_capture_done_cb2(tdm_capture *capture, tbm_surface_h buffer, void *user_data)
+_tc_tdm_capture_done_cb2(tdm_capture *capture, tbm_surface_h buffer, void *user_data)
 {
        int *done = (int*)user_data;
        if (done)
@@ -661,7 +661,7 @@ TEST_P(TDMBackendCapture, CaptureDestroyWithoutCommit)
                const tdm_output_mode *mode = NULL;
                int f = 0;
 
-               if (!ut_tdm_output_is_connected(outputs[o]))
+               if (!tc_tdm_output_is_connected(outputs[o]))
                        continue;
 
                ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
@@ -671,7 +671,7 @@ TEST_P(TDMBackendCapture, CaptureDestroyWithoutCommit)
                ASSERT_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, _ut_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE);
+               ASSERT_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);
@@ -692,7 +692,7 @@ TEST_P(TDMBackendCapture, CaptureDestroyBeforeDone)
                const tdm_output_mode *mode = NULL;
                int f = 0;
 
-               if (!ut_tdm_output_is_connected(outputs[o]))
+               if (!tc_tdm_output_is_connected(outputs[o]))
                        continue;
 
                ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
@@ -702,7 +702,7 @@ TEST_P(TDMBackendCapture, CaptureDestroyBeforeDone)
                ASSERT_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, _ut_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE);
+               ASSERT_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);
@@ -727,7 +727,7 @@ TEST_P(TDMBackendCapture, CaptureOneshotLetterboxSize)
        for (int o = 0; o < output_count; o++) {
                const tdm_output_mode *mode = NULL;
 
-               if (!ut_tdm_output_is_connected(outputs[o]))
+               if (!tc_tdm_output_is_connected(outputs[o]))
                        continue;
 
                ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
@@ -752,7 +752,7 @@ TEST_P(TDMBackendCapture, CaptureOneshotLetterboxSize)
                        ASSERT_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, _ut_tdm_capture_done_cb, &done), TDM_ERROR_NONE);
+                       ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, &done), TDM_ERROR_NONE);
 
 retry:
                        for (int b = 0; b < 3; b++) {
@@ -761,7 +761,7 @@ retry:
                                ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
 
                                while (!done)
-                                       ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+                                       ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
 
 #if 0
                                char temp[256];
@@ -793,7 +793,7 @@ TEST_P(TDMBackendCapture, CaptureOneshotFullSize)
        for (int o = 0; o < output_count; o++) {
                const tdm_output_mode *mode = NULL;
 
-               if (!ut_tdm_output_is_connected(outputs[o]))
+               if (!tc_tdm_output_is_connected(outputs[o]))
                        continue;
 
                ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
@@ -818,7 +818,7 @@ TEST_P(TDMBackendCapture, CaptureOneshotFullSize)
                        ASSERT_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, _ut_tdm_capture_done_cb, &done), TDM_ERROR_NONE);
+                       ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, &done), TDM_ERROR_NONE);
 
 retry:
                        for (int b = 0; b < 3; b++) {
@@ -827,7 +827,7 @@ retry:
                                ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
 
                                while (!done)
-                                       ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+                                       ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
 
 #if 0
                                char temp[256];
@@ -859,7 +859,7 @@ TEST_P(TDMBackendCapture, CaptureOneshotAttachFewTimesInOneCommit)
        for (int o = 0; o < output_count; o++) {
                const tdm_output_mode *mode = NULL;
 
-               if (!ut_tdm_output_is_connected(outputs[o]))
+               if (!tc_tdm_output_is_connected(outputs[o]))
                        continue;
 
                ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
@@ -885,7 +885,7 @@ TEST_P(TDMBackendCapture, CaptureOneshotAttachFewTimesInOneCommit)
                                                                  TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true);
 
                        done = 0;
-                       ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb2, &done), TDM_ERROR_NONE);
+                       ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb2, &done), TDM_ERROR_NONE);
 
 retry:
                        for (int b = 0; b < 3; b++)
@@ -894,7 +894,7 @@ retry:
                        ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
 
                        while (done != 3)
-                               ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+                               ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
 
                        for (int b = 0; b < 3; b++) {
 #if 0
@@ -917,18 +917,18 @@ retry:
 }
 
 static void
-_ut_tdm_backend_capture_buffer_release_cb(tbm_surface_h buffer, void *user_data)
+_tc_tdm_backend_capture_buffer_release_cb(tbm_surface_h buffer, void *user_data)
 {
        TDMBackendCapture *backend_capture = (TDMBackendCapture*)user_data;
 
-       tdm_buffer_remove_release_handler(buffer, _ut_tdm_backend_capture_buffer_release_cb, backend_capture);
+       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);
 }
 
 static void
-_ut_tdm_capture_stream_done_cb(tdm_capture *capture, tbm_surface_h buffer, void *user_data)
+_tc_tdm_capture_stream_done_cb(tdm_capture *capture, tbm_surface_h buffer, void *user_data)
 {
        TDMBackendCapture *backend_capture = (TDMBackendCapture*)user_data;
 
@@ -939,7 +939,7 @@ _ut_tdm_capture_stream_done_cb(tdm_capture *capture, tbm_surface_h buffer, void
                        snprintf(temp, sizeof temp, "f%d_b%d", f, b);
                        DumpBuffer(b, temp);
 #endif
-                       tdm_buffer_add_release_handler(buffer, _ut_tdm_backend_capture_buffer_release_cb, (void*)backend_capture);
+                       tdm_buffer_add_release_handler(buffer, _tc_tdm_backend_capture_buffer_release_cb, (void*)backend_capture);
                        backend_capture->ShowBuffer(b, &backend_capture->dst_pos);
                        break;
                }
@@ -959,7 +959,7 @@ TEST_P(TDMBackendCapture, CaptureStreamLetterboxSize)
        for (int o = 0; o < output_count; o++) {
                const tdm_output_mode *mode = NULL;
 
-               if (!ut_tdm_output_is_connected(outputs[o]))
+               if (!tc_tdm_output_is_connected(outputs[o]))
                        continue;
 
                ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
@@ -984,7 +984,7 @@ TEST_P(TDMBackendCapture, CaptureStreamLetterboxSize)
                        ASSERT_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, _ut_tdm_capture_stream_done_cb, (void*)this), TDM_ERROR_NONE);
+                       ASSERT_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);
@@ -997,7 +997,7 @@ retry:
                        ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
 
                        while (!stream_exit)
-                               ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+                               ASSERT_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);
@@ -1019,7 +1019,7 @@ TEST_P(TDMBackendCapture, CaptureStreamFullSize)
        for (int o = 0; o < output_count; o++) {
                const tdm_output_mode *mode = NULL;
 
-               if (!ut_tdm_output_is_connected(outputs[o]))
+               if (!tc_tdm_output_is_connected(outputs[o]))
                        continue;
 
                ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
@@ -1044,7 +1044,7 @@ TEST_P(TDMBackendCapture, CaptureStreamFullSize)
                        ASSERT_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, _ut_tdm_capture_stream_done_cb, (void*)this), TDM_ERROR_NONE);
+                       ASSERT_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);
@@ -1057,7 +1057,7 @@ retry:
                        ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
 
                        while (!stream_exit)
-                               ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+                               ASSERT_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);