haltest: support hwc mode

skip tdm_layer api and output_commit api test if hwc enabled.
do not show the test result to screen if hwc enabled.

Change-Id: I80bee46fa75f16bc34cdb00e3f6c7129295bfd95
Signed-off-by: Junkyeong Kim <jk0430.kim@samsung.com>

diff --git a/haltests/src/tc_tdm.h b/haltests/src/tc_tdm.h
index 853f45a..e118e77 100644 (file)
--- a/haltests/src/tc_tdm.h
+++ b/haltests/src/tc_tdm.h
@@ -49,13 +49,13 @@ extern bool enable_porting_debug;
 
 #define TDM_UT_CHECK_FLAG(FLAG) \
        do {\
-               if(!(FLAG)) \
+               if (!(FLAG)) \
                        TDM_UT_WRN("[          ] not supported");\
        } while(0)
 
 #define TDM_UT_SKIP_FLAG(FLAG) \
        do {\
-               if(!(FLAG)) {\
+               if (!(FLAG)) {\
                        TDM_UT_WRN("[  SKIPPED ] not supported");\
                        return;\
                }\

diff --git a/haltests/src/tc_tdm_backend_capture.cpp b/haltests/src/tc_tdm_backend_capture.cpp
index 010153f..006430e 100644 (file)
--- a/haltests/src/tc_tdm_backend_capture.cpp
+++ b/haltests/src/tc_tdm_backend_capture.cpp
@@ -259,6 +259,9 @@ bool TDMBackendCapture::TestPrepare(int output_idx, int w, int h, tbm_format fmt
                        flags |= TBM_BO_SCANOUT;
        }
 
+       if (tc_tdm_output_is_hwc_enable(outputs[output_idx]))
+               flags |= TBM_BO_SCANOUT;
+
        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);
@@ -573,7 +576,10 @@ TEST_P(TDMBackendCapture, CaptureAttach)
                        continue;
 
                for (int f = 0; f < format_count; f++) {
-                       FindLayer(o, formats[f], &dst_pos);
+                       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],
                                                                  TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true);
@@ -666,7 +672,10 @@ TEST_P(TDMBackendCapture, CaptureDestroyWithoutCommit)
 
                ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
 
-               FindLayer(o, formats[f], &dst_pos);
+               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],
                                                          TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true);
@@ -697,7 +706,10 @@ TEST_P(TDMBackendCapture, CaptureDestroyBeforeDone)
 
                ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
 
-               FindLayer(o, formats[f], &dst_pos);
+               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],
                                                          TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true);
@@ -742,11 +754,15 @@ TEST_P(TDMBackendCapture, CaptureOneshotLetterboxSize)
 
                        TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
 
-                       FindLayer(o, formats[f], &dst_pos);
+                       if (tc_tdm_output_is_hwc_enable(outputs[o]))
+                               dst_layer = NULL;
+                       else {
+                               FindLayer(o, formats[f], &dst_pos);
 
-                       if (!dst_layer) {
-                               TDM_UT_INFO("no proper layer for %c%c%c%c", FOURCC_STR(formats[f]));
-                               continue;
+                               if (!dst_layer) {
+                                       TDM_UT_INFO("no proper layer for %c%c%c%c", FOURCC_STR(formats[f]));
+                                       continue;
+                               }
                        }
 
                        ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f],
@@ -768,14 +784,17 @@ retry:
                                snprintf(temp, sizeof temp, "f%d_b%d", f, b);
                                DumpBuffer(b, temp);
 #endif
-                               ShowBuffer(b, &dst_pos);
+                               if (tc_tdm_output_is_hwc_enable(outputs[o]))
+                                       TDM_UT_WRN("hwc_enable, not support showing buffer");
+                               else
+                                       ShowBuffer(b, &dst_pos);
                        }
 
                        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);
 
-
-                       HideLayer();
+                       if (!tc_tdm_output_is_hwc_enable(outputs[o]))
+                               HideLayer();
 
                        TestDone();
                }
@@ -808,11 +827,15 @@ TEST_P(TDMBackendCapture, CaptureOneshotFullSize)
 
                        TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
 
-                       FindLayer(o, formats[f], &dst_pos);
+                       if (tc_tdm_output_is_hwc_enable(outputs[o]))
+                               dst_layer = NULL;
+                       else {
+                               FindLayer(o, formats[f], &dst_pos);
 
-                       if (!dst_layer) {
-                               TDM_UT_INFO("no proper layer for %c%c%c%c", FOURCC_STR(formats[f]));
-                               continue;
+                               if (!dst_layer) {
+                                       TDM_UT_INFO("no proper layer for %c%c%c%c", FOURCC_STR(formats[f]));
+                                       continue;
+                               }
                        }
 
                        ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f],
@@ -834,14 +857,17 @@ retry:
                                snprintf(temp, sizeof temp, "f%d_b%d", f, b);
                                DumpBuffer(b, temp);
 #endif
-                               ShowBuffer(b, &dst_pos);
+                               if (tc_tdm_output_is_hwc_enable(outputs[o]))
+                                       TDM_UT_WRN("hwc_enable, not support showing buffer");
+                               else
+                                       ShowBuffer(b, &dst_pos);
                        }
 
                        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);
 
-
-                       HideLayer();
+                       if (!tc_tdm_output_is_hwc_enable(outputs[o]))
+                               HideLayer();
 
                        TestDone();
                }
@@ -874,11 +900,15 @@ TEST_P(TDMBackendCapture, CaptureOneshotAttachFewTimesInOneCommit)
 
                        TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
 
-                       FindLayer(o, formats[f], &dst_pos);
+                       if (tc_tdm_output_is_hwc_enable(outputs[o]))
+                               dst_layer = NULL;
+                       else {
+                               FindLayer(o, formats[f], &dst_pos);
 
-                       if (!dst_layer) {
-                               TDM_UT_INFO("no proper layer for %c%c%c%c", FOURCC_STR(formats[f]));
-                               continue;
+                               if (!dst_layer) {
+                                       TDM_UT_INFO("no proper layer for %c%c%c%c", FOURCC_STR(formats[f]));
+                                       continue;
+                               }
                        }
 
                        ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f],
@@ -902,14 +932,17 @@ retry:
                                snprintf(temp, sizeof temp, "f%d_b%d", f, b);
                                DumpBuffer(b, temp);
 #endif
-                               ShowBuffer(b, &dst_pos);
+                               if (tc_tdm_output_is_hwc_enable(outputs[o]))
+                                       TDM_UT_WRN("hwc_enable, not support showing buffer");
+                               else
+                                       ShowBuffer(b, &dst_pos);
                        }
 
                        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);
 
-
-                       HideLayer();
+                       if (!tc_tdm_output_is_hwc_enable(outputs[o]))
+                               HideLayer();
 
                        TestDone();
                }
@@ -940,7 +973,12 @@ _tc_tdm_capture_stream_done_cb(tdm_capture *capture, tbm_surface_h buffer, void
                        DumpBuffer(b, temp);
 #endif
                        tdm_buffer_add_release_handler(buffer, _tc_tdm_backend_capture_buffer_release_cb, (void*)backend_capture);
-                       backend_capture->ShowBuffer(b, &backend_capture->dst_pos);
+                       if (tc_tdm_output_is_hwc_enable(backend_capture->output)) {
+                               TDM_UT_WRN("hwc_enable, not support showing buffer");
+                               _tc_tdm_backend_capture_buffer_release_cb(buffer, user_data);
+                       }
+                       else
+                               backend_capture->ShowBuffer(b, &backend_capture->dst_pos);
                        break;
                }
        }
@@ -974,11 +1012,15 @@ TEST_P(TDMBackendCapture, CaptureStreamLetterboxSize)
 
                        TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
 
-                       FindLayer(o, formats[f], &dst_pos);
+                       if (tc_tdm_output_is_hwc_enable(outputs[o]))
+                               dst_layer = NULL;
+                       else {
+                               FindLayer(o, formats[f], &dst_pos);
 
-                       if (!dst_layer) {
-                               TDM_UT_INFO("no proper layer for %c%c%c%c", FOURCC_STR(formats[f]));
-                               continue;
+                               if (!dst_layer) {
+                                       TDM_UT_INFO("no proper layer for %c%c%c%c", FOURCC_STR(formats[f]));
+                                       continue;
+                               }
                        }
 
                        ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f],
@@ -1002,8 +1044,8 @@ retry:
                        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);
 
-
-                       HideLayer();
+                       if (!tc_tdm_output_is_hwc_enable(outputs[o]))
+                               HideLayer();
 
                        TestDone();
                }
@@ -1034,11 +1076,15 @@ TEST_P(TDMBackendCapture, CaptureStreamFullSize)
 
                        TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
 
-                       FindLayer(o, formats[f], &dst_pos);
+                       if (tc_tdm_output_is_hwc_enable(outputs[o]))
+                               dst_layer = NULL;
+                       else {
+                               FindLayer(o, formats[f], &dst_pos);
 
-                       if (!dst_layer) {
-                               TDM_UT_INFO("no proper layer for %c%c%c%c", FOURCC_STR(formats[f]));
-                               continue;
+                               if (!dst_layer) {
+                                       TDM_UT_INFO("no proper layer for %c%c%c%c", FOURCC_STR(formats[f]));
+                                       continue;
+                               }
                        }
 
                        ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f],
@@ -1062,8 +1108,8 @@ retry:
                        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);
 
-
-                       HideLayer();
+                       if (!tc_tdm_output_is_hwc_enable(outputs[o]))
+                               HideLayer();
 
                        TestDone();
                }

diff --git a/haltests/src/tc_tdm_backend_display.cpp b/haltests/src/tc_tdm_backend_display.cpp
index 7fd8464..b79cbd8 100644 (file)
--- a/haltests/src/tc_tdm_backend_display.cpp
+++ b/haltests/src/tc_tdm_backend_display.cpp
@@ -167,6 +167,9 @@ TEST_P(TDMBackendBasic, VerifyLayerObject)
                tdm_output *output = tdm_display_get_output(dpy, o, &ret);
                ASSERT_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);
                TDM_UT_ASSERT_TRUE(layer_count > 0,
@@ -220,6 +223,9 @@ TEST_P(TDMBackendBasic, VerifyLayerGetProperty)
                tdm_output *output = tdm_display_get_output(dpy, o, &ret);
                ASSERT_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);
 
@@ -324,6 +330,9 @@ TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowOneFrame)
                if (!tc_tdm_output_is_connected(outputs[o]))
                        continue;
 
+               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);
 
@@ -354,6 +363,9 @@ TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowManyFrames)
                if (!tc_tdm_output_is_connected(outputs[o]))
                        continue;
 
+               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);
 
@@ -400,6 +412,9 @@ TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowOneFrameWithCommitHandler)
                if (!tc_tdm_output_is_connected(outputs[o]))
                        continue;
 
+               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);
 
@@ -433,6 +448,9 @@ TEST_P(TDMBackendBasic, VerifyOverlayLayersShowOneFrame)
                if (!tc_tdm_output_is_connected(outputs[o]))
                        continue;
 
+               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);
 
@@ -480,6 +498,9 @@ TEST_P(TDMBackendBasic, VerifyOverlayLayersShowManyFrames)
                if (!tc_tdm_output_is_connected(outputs[o]))
                        continue;
 
+               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);
 
@@ -554,14 +575,16 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblank)
                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);
 
-               layer = tc_tdm_output_get_primary_layer(outputs[o]);
-               ASSERT_NE(layer, NULL);
+               if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
+                       layer = tc_tdm_output_get_primary_layer(outputs[o]);
+                       ASSERT_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);
-               DestroyBuffers();
+                       ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
+                       ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
+                       DestroyBuffers();
 
-               ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+                       ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+               }
 
                /* start from 1 */
                for (int t = 1; t < 10; t++) {
@@ -604,14 +627,16 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblankInterval)
                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);
 
-               layer = tc_tdm_output_get_primary_layer(outputs[o]);
-               ASSERT_NE(layer, NULL);
+               if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
+                       layer = tc_tdm_output_get_primary_layer(outputs[o]);
+                       ASSERT_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);
-               DestroyBuffers();
+                       ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
+                       ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
+                       DestroyBuffers();
 
-               ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+                       ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+               }
 
                /* start from 1 */
                for (int t = 1; t < 10; t++) {
@@ -651,14 +676,16 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblankFewTimesInOneVblank)
                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);
 
-               layer = tc_tdm_output_get_primary_layer(outputs[o]);
-               ASSERT_NE(layer, NULL);
+               if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
+                       layer = tc_tdm_output_get_primary_layer(outputs[o]);
+                       ASSERT_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);
-               DestroyBuffers();
+                       ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
+                       ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
+                       DestroyBuffers();
 
-               ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+                       ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+               }
 
                /* start from 1 */
                for (int t = 1; t < 10; t++) {
@@ -845,6 +872,9 @@ TEST_P(TDMBackendDisplay, VerifyPirmaryLayerFormat)
                if (!tc_tdm_output_is_connected(outputs[o]))
                        continue;
 
+               if (tc_tdm_output_is_hwc_enable(outputs[o]))
+                       TDM_UT_SKIP_FLAG(0);
+
                layer = tc_tdm_output_get_primary_layer(outputs[o]);
                ASSERT_NE(layer, NULL);
 
@@ -888,6 +918,13 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat)
 {
        ASSERT_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);
+                       TDM_UT_SKIP_FLAG(0);
+               }
+       }
+
        for (int l = 0; l < layer_count; l++) {
                tdm_error ret;
                tdm_output *output;
@@ -958,6 +995,13 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize)
 {
        ASSERT_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);
+                       TDM_UT_SKIP_FLAG(0);
+               }
+       }
+
        for (int l = 0; l < layer_count; l++) {
                tdm_error ret;
                tdm_output *output;
@@ -1033,6 +1077,13 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerScale)
 {
        ASSERT_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);
+                       TDM_UT_SKIP_FLAG(0);
+               }
+       }
+
        for (int l = 0; l < layer_count; l++) {
                tdm_error ret;
                tdm_output *output;
@@ -1122,6 +1173,13 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition)
 {
        ASSERT_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);
+                       TDM_UT_SKIP_FLAG(0);
+               }
+       }
+
        for (int l = 0; l < layer_count; l++) {
                tdm_error ret;
                tdm_output *output;
@@ -1210,6 +1268,13 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop)
 {
        ASSERT_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);
+                       TDM_UT_SKIP_FLAG(0);
+               }
+       }
+
        for (int l = 0; l < layer_count; l++) {
                tdm_error ret;
                tdm_output *output;
@@ -1355,6 +1420,9 @@ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithoutComm
                if (!tc_tdm_output_is_connected(outputs[o]))
                        continue;
 
+               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);
 
                tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]);
@@ -1375,6 +1443,11 @@ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithCommit)
 
                ASSERT_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);
+                       TDM_UT_SKIP_FLAG(0);
+               }
+
                tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]);
                ASSERT_NE(layer, NULL);
 
@@ -1397,6 +1470,11 @@ TEST_P(TDMBackendDisplay, VerifyLayerGetInfo)
                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);
+                       TDM_UT_SKIP_FLAG(0);
+               }
+
                tbm_surface_h displaying_buffer;
                tdm_error ret;
                tdm_info_layer info, temp;

diff --git a/haltests/src/tc_tdm_backend_pp.cpp b/haltests/src/tc_tdm_backend_pp.cpp
index 424b36c..f739d96 100644 (file)
--- a/haltests/src/tc_tdm_backend_pp.cpp
+++ b/haltests/src/tc_tdm_backend_pp.cpp
@@ -56,6 +56,7 @@ public:
 
        tdm_layer *dst_layer;
        const tbm_format *dst_formats;
+       tbm_format *pp_formats;
        int dst_format_count;
        int dst_zpos;
        int dst_layer_index;
@@ -96,6 +97,7 @@ TDMBackendPP::TDMBackendPP()
        dst_format_count = 0;
        dst_zpos = 0;
        dst_layer_index = 0;
+       pp_formats = NULL;
 }
 
 void TDMBackendPP::SetUp(void)
@@ -136,6 +138,7 @@ void TDMBackendPP::TearDown(void)
                tdm_pp_destroy(pp);
 
        DestroyBuffers();
+       ASSERT_EQ(tc_tdm_output_unset(dpy, output), true);
 
        TDMBackendDisplay::TearDown();
 }
@@ -174,6 +177,9 @@ bool TDMBackendPP::PrepareBuffers(int sw, int sh, tbm_format sf, int dw, int dh,
                        dst_flags |= TBM_BO_SCANOUT;
        }
 
+       if (tc_tdm_output_is_hwc_enable(output))
+               dst_flags |= TBM_BO_SCANOUT;
+
        TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_buffer_create(sw, sh, sf, src_flags, true, 3, srcbuf) == true);
        TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_buffer_create(dw, dh, df, dst_flags, false, 3, dstbuf) == true);
        TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_pp_fill_info(srcbuf[0], dstbuf[0], t, &info) == true);
@@ -187,6 +193,19 @@ bool TDMBackendPP::FindLayerUnderPrimary(void)
        tdm_error ret;
        int count;
        int primary_zpos, zpos;
+
+       if (tc_tdm_output_is_hwc_enable(output)) {
+               pp_formats = (tbm_format *)calloc(1, sizeof(tbm_format) * 2);
+               pp_formats[0] = TBM_FORMAT_NV12;
+               pp_formats[1] = TBM_FORMAT_YUV420;
+               dst_formats = pp_formats;
+               dst_format_count = 2;
+               TDM_UT_RETURN_FALSE_IF_FAIL(dst_formats != NULL);
+               TDM_UT_RETURN_FALSE_IF_FAIL(dst_format_count > 0);
+               dst_layer = NULL;
+               return true;
+       }
+
        tdm_layer *primary = tc_tdm_output_get_primary_layer(output);
        TDM_UT_RETURN_FALSE_IF_FAIL(primary != NULL);
        TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_layer_count(output, &count) == TDM_ERROR_NONE);
@@ -217,6 +236,19 @@ bool TDMBackendPP::FindLayerOverPrimary(void)
        tdm_error ret;
        int count;
        int primary_zpos, zpos;
+
+       if (tc_tdm_output_is_hwc_enable(output)) {
+               pp_formats = (tbm_format *)calloc(1, sizeof(tbm_format) * 2);
+               pp_formats[0] = TBM_FORMAT_ARGB8888;
+               pp_formats[1] = TBM_FORMAT_XRGB8888;
+               dst_formats = formats;
+               dst_format_count = 2;
+               TDM_UT_RETURN_FALSE_IF_FAIL(dst_formats != NULL);
+               TDM_UT_RETURN_FALSE_IF_FAIL(dst_format_count > 0);
+               dst_layer = NULL;
+               return true;
+       }
+
        tdm_layer *primary = tc_tdm_output_get_primary_layer(output);
        TDM_UT_RETURN_FALSE_IF_FAIL(primary != NULL);
        TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_layer_count(output, &count) == TDM_ERROR_NONE);
@@ -254,6 +286,9 @@ _tc_tdm_backend_pp_output_commit_cb(tdm_output *output, unsigned int sequence,
 void TDMBackendPP::ShowBuffer(int b)
 {
        ASSERT_NE(output, NULL);
+       if (tc_tdm_output_is_hwc_enable(output))
+               TDM_UT_SKIP_FLAG(0);
+
        ASSERT_NE(dst_layer, NULL);
 
        bool done = false;
@@ -268,6 +303,9 @@ void TDMBackendPP::ShowBuffer(int b)
 void TDMBackendPP::HideLayer(void)
 {
        ASSERT_NE(output, NULL);
+       if (tc_tdm_output_is_hwc_enable(output))
+               TDM_UT_SKIP_FLAG(0);
+
        ASSERT_NE(dst_layer, NULL);
 
        tdm_layer_unset_buffer(dst_layer);
@@ -525,7 +563,8 @@ TEST_P(TDMBackendPP, PPConvertUnderlay)
 
        FindLayerUnderPrimary();
 
-       ASSERT_NE(dst_layer, NULL);
+       if (!tc_tdm_output_is_hwc_enable(output))
+               ASSERT_NE(dst_layer, NULL);
 
        for (int f = 0; f < dst_format_count; f++) {
                bool done;
@@ -564,6 +603,10 @@ retry:
                DestroyPP();
                DestroyBuffers();
        }
+       if (tc_tdm_output_is_hwc_enable(output) && pp_formats) {
+               free(pp_formats);
+               pp_formats = NULL;
+       }
 }
 
 TEST_P(TDMBackendPP, PPConvertOverlay)
@@ -572,7 +615,8 @@ TEST_P(TDMBackendPP, PPConvertOverlay)
 
        FindLayerOverPrimary();
 
-       TDM_UT_SKIP_FLAG(dst_layer != NULL);
+       if (!tc_tdm_output_is_hwc_enable(output))
+               TDM_UT_SKIP_FLAG(dst_layer != NULL);
 
        for (int f = 0; f < dst_format_count; f++) {
                bool done;
@@ -611,6 +655,10 @@ retry:
                DestroyPP();
                DestroyBuffers();
        }
+       if (tc_tdm_output_is_hwc_enable(output) && pp_formats) {
+               free(pp_formats);
+               pp_formats = NULL;
+       }
 }
 
 TEST_P(TDMBackendPP, PPConvertScale)
@@ -619,7 +667,8 @@ TEST_P(TDMBackendPP, PPConvertScale)
 
        FindLayerUnderPrimary();
 
-       ASSERT_NE(dst_layer, NULL);
+       if (!tc_tdm_output_is_hwc_enable(output))
+               ASSERT_NE(dst_layer, NULL);
 
        for (int f = 0; f < dst_format_count; f++) {
                bool done;
@@ -658,6 +707,10 @@ retry:
                DestroyPP();
                DestroyBuffers();
        }
+       if (tc_tdm_output_is_hwc_enable(output) && pp_formats) {
+               free(pp_formats);
+               pp_formats = NULL;
+       }
 }
 
 TEST_P(TDMBackendPP, PPConvertTransform)
@@ -666,7 +719,8 @@ TEST_P(TDMBackendPP, PPConvertTransform)
 
        FindLayerUnderPrimary();
 
-       ASSERT_NE(dst_layer, NULL);
+       if (!tc_tdm_output_is_hwc_enable(output))
+               ASSERT_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++) {
@@ -707,6 +761,10 @@ retry:
                        DestroyBuffers();
                }
        }
+       if (tc_tdm_output_is_hwc_enable(output) && pp_formats) {
+               free(pp_formats);
+               pp_formats = NULL;
+       }
 }
 
 TEST_P(TDMBackendPP, PPConvertCSC)
@@ -716,7 +774,8 @@ TEST_P(TDMBackendPP, PPConvertCSC)
 
        FindLayerUnderPrimary();
 
-       ASSERT_NE(dst_layer, NULL);
+       if (!tc_tdm_output_is_hwc_enable(output))
+               ASSERT_NE(dst_layer, NULL);
 
        for (int df = 0; df < dst_format_count; df++) {
                for (int sf = 0; sf < format_count; sf++) {
@@ -758,6 +817,10 @@ retry:
                        DestroyBuffers();
                }
        }
+       if (tc_tdm_output_is_hwc_enable(output) && pp_formats) {
+               free(pp_formats);
+               pp_formats = NULL;
+       }
 }
 
 

diff --git a/haltests/src/tc_tdm_helper.cpp b/haltests/src/tc_tdm_helper.cpp
index 4509cd0..6ac40da 100644 (file)
--- a/haltests/src/tc_tdm_helper.cpp
+++ b/haltests/src/tc_tdm_helper.cpp
@@ -415,6 +415,9 @@ TEST_P(TDMHelper, HelperCaptureOutput)
                if (!tc_tdm_output_is_connected(output))
                        continue;
 
+               if (tc_tdm_output_is_hwc_enable(outputs[o]))
+                       TDM_UT_SKIP_FLAG(0);
+
                ASSERT_EQ(tc_tdm_output_prepare(dpy, output, true), true);
 
                dump = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);

diff --git a/haltests/src/tc_tdm_hwc.cpp b/haltests/src/tc_tdm_hwc.cpp
index 541414f..b3618e9 100644 (file)
--- a/haltests/src/tc_tdm_hwc.cpp
+++ b/haltests/src/tc_tdm_hwc.cpp
@@ -209,7 +209,7 @@ TEST_P(TDMHwc, GetClientTargetBufferQueueFailNullObject)
        }
 }
 
-TEST_P(TDMHwc, GetClientTargetBufferQueueFainNoHwc)
+TEST_P(TDMHwc, GetClientTargetBufferQueueFailNoHwc)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
@@ -221,8 +221,8 @@ TEST_P(TDMHwc, GetClientTargetBufferQueueFainNoHwc)
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
-                       ASSERT_EQ(TDM_ERROR_NONE, error);
-                       ASSERT_NE(NULL, queue);
+                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       ASSERT_EQ(NULL, queue);
                } else {
                        queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
                        ASSERT_NE(TDM_ERROR_NONE, error);
@@ -240,6 +240,7 @@ 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);
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
@@ -291,9 +292,11 @@ 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);
                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);
                        target_buff = tbm_surface_internal_create_with_flags(mode->hdisplay, mode->vdisplay,
                                                                        TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
                        ASSERT_NE(NULL, target_buff);
@@ -315,13 +318,12 @@ TEST_P(TDMHwc, SetClientTargetBufferSuccessfulResetBuff)
        tdm_hwc *hwc = NULL;
        tdm_error error = TDM_ERROR_NONE;
        tdm_region damage = {.num_rects = 0, .rects = NULL};
-       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);
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        error = tdm_hwc_set_client_target_buffer(hwc, NULL, damage);
-                       tbm_surface_internal_destroy(target_buff);
                        ASSERT_EQ(TDM_ERROR_NONE, error);
                } else {
                        error = tdm_hwc_set_client_target_buffer(hwc, NULL, damage);
@@ -396,7 +398,7 @@ TEST_P(TDMHwc, AcceptChangesFailNoHwc)
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        error = tdm_hwc_accept_validation(hwc);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       ASSERT_EQ(TDM_ERROR_NONE, error);
                } else {
                        error = tdm_hwc_accept_validation(hwc);
                        ASSERT_NE(TDM_ERROR_NONE, error);
@@ -417,6 +419,7 @@ 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);
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        for (int w = 0; w < HWC_WIN_NUM; w++) {
@@ -433,11 +436,12 @@ TEST_P(TDMHwc, AcceptChangesSuccessful)
                                changed_hwc_window = (tdm_hwc_window **)calloc(num_types, sizeof(tdm_hwc_window *));
                                composition_types = (tdm_hwc_window_composition *)calloc(num_types, sizeof(tdm_hwc_window_composition));
 
+                               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);
 
-                               error =  tdm_hwc_accept_validation(hwc);
+                               error = tdm_hwc_accept_validation(hwc);
                                ASSERT_EQ(TDM_ERROR_NONE, error);
 
                                free(composition_types);
@@ -474,6 +478,7 @@ 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);
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        for (int w = 0; w < HWC_WIN_NUM; w++) {
@@ -490,6 +495,7 @@ TEST_P(TDMHwc, CommitSuccessful)
                                changed_hwc_window = (tdm_hwc_window **)calloc(num_types, sizeof(tdm_hwc_window *));
                                composition_types = (tdm_hwc_window_composition *)calloc(num_types, sizeof(tdm_hwc_window_composition));
 
+                               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);
@@ -502,7 +508,7 @@ TEST_P(TDMHwc, CommitSuccessful)
                        }
 
                        error = tdm_hwc_commit(hwc, 0, _tc_tdm_hwc_commit_cb, NULL);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       ASSERT_EQ(TDM_ERROR_NONE, error);
 
                        for (int w = 0; w < HWC_WIN_NUM; w++)
                                tdm_hwc_window_destroy(hwc_wnds[w]);

diff --git a/haltests/src/tc_tdm_output.cpp b/haltests/src/tc_tdm_output.cpp
index 15224f0..75aefe4 100644 (file)
--- a/haltests/src/tc_tdm_output.cpp
+++ b/haltests/src/tc_tdm_output.cpp
@@ -181,6 +181,23 @@ _tc_tdm_output_done_cb(tdm_output *output, unsigned int sequence,
 }
 
 bool
+tc_tdm_output_prepare_hwc_buffer(tdm_output *output, tbm_surface_h *buffers, int buffer_count, bool fill)
+{
+       int w, h;
+       const tdm_output_mode *mode = NULL;
+
+       TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE);
+       TDM_UT_RETURN_FALSE_IF_FAIL(mode != NULL);
+
+       w = mode->hdisplay;
+       h = mode->vdisplay;
+
+       TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_buffer_create(w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT, fill, buffer_count, buffers) == true);
+
+       return true;
+}
+
+bool
 tc_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill)
 {
        tbm_surface_h buffer = NULL;
@@ -189,27 +206,41 @@ tc_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill)
        tdm_layer *layer;
        bool done = false;
        tdm_output_conn_status status;
+       tdm_region fb_damage;
+       tdm_hwc *thwc = NULL;
+       uint32_t num = 0;
 
        TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_output_is_connected(output) == true);
        TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_output_mode_setting(output) == true);
        TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE);
 
-       TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_primary_index(output, &primary_index) == TDM_ERROR_NONE);
-       TDM_UT_RETURN_FALSE_IF_FAIL(primary_index >= 0);
+       if (tc_tdm_output_is_hwc_enable(output)) {
+               TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_output_prepare_hwc_buffer(output, &buffer, 1, fill) == true);
+               thwc = tdm_output_get_hwc(output, &ret);
+               TDM_UT_GOTO_IF_FAIL(thwc != NULL, failed);
 
-       layer = tdm_output_get_layer(output, primary_index, &ret);
-       TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
-       TDM_UT_RETURN_FALSE_IF_FAIL(layer != NULL);
+               TDM_UT_GOTO_IF_FAIL(tdm_hwc_set_client_target_buffer(thwc, buffer, fb_damage) == TDM_ERROR_NONE, failed);
+               TDM_UT_GOTO_IF_FAIL(tdm_hwc_validate(thwc, NULL, 0, &num) == TDM_ERROR_NONE, failed);
+               TDM_UT_GOTO_IF_FAIL(tdm_hwc_accept_validation(thwc) == TDM_ERROR_NONE, failed);
+               TDM_UT_GOTO_IF_FAIL(tdm_hwc_commit(thwc, 0, NULL, NULL) == TDM_ERROR_NONE, failed);
+       } else {
+               TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_primary_index(output, &primary_index) == TDM_ERROR_NONE);
+               TDM_UT_RETURN_FALSE_IF_FAIL(primary_index >= 0);
+
+               layer = tdm_output_get_layer(output, primary_index, &ret);
+               TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
+               TDM_UT_RETURN_FALSE_IF_FAIL(layer != NULL);
 
-       TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_prepare_buffer(layer, &buffer, 1, fill) == true);
-       TDM_UT_RETURN_FALSE_IF_FAIL(buffer != NULL);
+               TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_prepare_buffer(layer, &buffer, 1, fill) == true);
+               TDM_UT_RETURN_FALSE_IF_FAIL(buffer != NULL);
 
-       TDM_UT_GOTO_IF_FAIL(tc_tdm_layer_set_buffer(layer, buffer) == true, failed);
+               TDM_UT_GOTO_IF_FAIL(tc_tdm_layer_set_buffer(layer, buffer) == true, failed);
 
-       if (tdm_helper_output_commit_per_vblank_enabled(output))
-               TDM_UT_GOTO_IF_FAIL(tdm_layer_commit(layer, NULL, NULL) == TDM_ERROR_NONE, failed);
-       else
-               TDM_UT_GOTO_IF_FAIL(tdm_output_commit(output, 0, NULL, NULL) == TDM_ERROR_NONE, failed);
+               if (tdm_helper_output_commit_per_vblank_enabled(output))
+                       TDM_UT_GOTO_IF_FAIL(tdm_layer_commit(layer, NULL, NULL) == TDM_ERROR_NONE, failed);
+               else
+                       TDM_UT_GOTO_IF_FAIL(tdm_output_commit(output, 0, NULL, NULL) == TDM_ERROR_NONE, failed);
+       }
 
        TDM_UT_GOTO_IF_FAIL(tdm_output_get_conn_status(output, &status) == TDM_ERROR_NONE, failed);
        TDM_UT_GOTO_IF_FAIL(status == TDM_OUTPUT_CONN_STATUS_MODE_SETTED, failed);
@@ -246,21 +277,43 @@ tc_tdm_output_unset(tdm_display *dpy, tdm_output *output)
        tdm_error ret;
        int count = 0;
        unsigned int pipe = 0;
+       tdm_hwc *thwc = NULL;
+       const tdm_output_mode *mode = NULL;
+       tdm_output_dpms dpms = TDM_OUTPUT_DPMS_OFF;
+       tdm_region fb_damage;
+       uint32_t num = 0;
+
+       if (tc_tdm_output_is_hwc_enable(output)) {
+               TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE);
+               if (mode == NULL)
+                       return true;
+               TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_dpms(output, &dpms) == TDM_ERROR_NONE);
+               if (dpms != TDM_OUTPUT_DPMS_ON)
+                       return true;
+
+               thwc = tdm_output_get_hwc(output, &ret);
+               TDM_UT_RETURN_FALSE_IF_FAIL(thwc != NULL);
+
+               TDM_UT_RETURN_FALSE_IF_FAIL(tdm_hwc_set_client_target_buffer(thwc, NULL, fb_damage) == TDM_ERROR_NONE);
+               TDM_UT_RETURN_FALSE_IF_FAIL(tdm_hwc_validate(thwc, NULL, 0, &num) == TDM_ERROR_NONE);
+               TDM_UT_RETURN_FALSE_IF_FAIL(tdm_hwc_accept_validation(thwc) == TDM_ERROR_NONE);
+               TDM_UT_RETURN_FALSE_IF_FAIL(tdm_hwc_commit(thwc, 0, NULL, NULL) == TDM_ERROR_NONE);
+       } else {
+               TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_layer_count(output, &count) == TDM_ERROR_NONE);
+               TDM_UT_RETURN_FALSE_IF_FAIL(count > 0);
 
-       TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_layer_count(output, &count) == TDM_ERROR_NONE);
-       TDM_UT_RETURN_FALSE_IF_FAIL(count > 0);
+               for (int l = 0; l < count; l++) {
+                       tdm_layer *layer = tdm_output_get_layer(output, l, &ret);
+                       TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
+                       TDM_UT_RETURN_FALSE_IF_FAIL(layer != NULL);
 
-       for (int l = 0; l < count; l++) {
-               tdm_layer *layer = tdm_output_get_layer(output, l, &ret);
-               TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
-               TDM_UT_RETURN_FALSE_IF_FAIL(layer != NULL);
+                       if (tc_tdm_layer_is_cursor_layer(layer))
+                               continue;
+                       if (tc_tdm_layer_is_video_layer(layer))
+                               continue;
 
-               if (tc_tdm_layer_is_cursor_layer(layer))
-                       continue;
-               if (tc_tdm_layer_is_video_layer(layer))
-                       continue;
-
-               TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE);
+                       TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE);
+               }
        }
 
        TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE);
@@ -794,8 +847,12 @@ TEST_P(TDMOutput, OutputGetPrimaryIndex)
 
        for (int o = 0; o < output_count; o++) {
                int primary_index = TDM_UT_INVALID_VALUE;
-               ASSERT_EQ(tdm_output_get_primary_index(outputs[o], &primary_index), TDM_ERROR_NONE);
-               ASSERT_NE(primary_index, TDM_UT_INVALID_VALUE);
+
+               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);
+               } else
+                       TDM_UT_SKIP_FLAG(0);
        }
 }
 
@@ -1450,13 +1507,16 @@ TEST_P(TDMOutput, OutputCommit)
 
                        done1 = false;
                        start = tdm_helper_get_time();
-                       ASSERT_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);
-                       end = tdm_helper_get_time();
-
-                       /* "+ interval" consider the delay of socket communication between kernel and platform */
-                       ASSERT_LT((end - start), (interval + interval));
+                       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);
+                               while (!done1)
+                                       ASSERT_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));
+                       } else
+                               TDM_UT_SKIP_FLAG(0);
                }
        }
 }
@@ -1481,7 +1541,10 @@ TEST_P(TDMOutput, OutputCommitNullOther)
                        continue;
 
                ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
-               ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+               if (!tc_tdm_output_is_hwc_enable(outputs[o]))
+                       ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+               else
+                       TDM_UT_SKIP_FLAG(0);
        }
 }
 
@@ -1501,7 +1564,10 @@ TEST_P(TDMOutput, OutputCommitDpmsSuspend)
 
                ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
 
-               ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF);
+               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);
+               else
+                       TDM_UT_SKIP_FLAG(0);
        }
 }
 
@@ -1521,7 +1587,10 @@ TEST_P(TDMOutput, OutputCommitDpmsOff)
 
                ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
 
-               ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF);
+               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);
+               else
+                       TDM_UT_SKIP_FLAG(0);
        }
 }
 
@@ -1567,8 +1636,11 @@ TEST_P(TDMOutput, OutputCommitAfterLayerCommit)
 
                ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
 
-               ASSERT_EQ(tdm_output_get_primary_index(outputs[o], &index), TDM_ERROR_NONE);
-               ASSERT_NE(index, TDM_UT_INVALID_VALUE);
+               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);
+               } else
+                       TDM_UT_SKIP_FLAG(0);
 
                layer = tdm_output_get_layer(outputs[o], index, &ret);
                ASSERT_EQ(ret, TDM_ERROR_NONE);
@@ -1609,12 +1681,15 @@ TEST_P(TDMOutput, OutputCommitFewTimesInOneVblank)
                ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
 
                for (int t = 0; t < 10; t++) {
-                       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);
-                       while (!done1 || !done2 || !done3)
-                               ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+                       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);
+                               while (!done1 || !done2 || !done3)
+                                       ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+                       } else
+                               TDM_UT_SKIP_FLAG(0);
                }
        }
 }
@@ -1640,13 +1715,16 @@ TEST_P(TDMOutput, OutputRemoveCommitHandler)
                ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
 
                for (int t = 0; t < 10; t++) {
-                       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);
-                       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);
+                       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);
+                               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);
+                       } else
+                               TDM_UT_SKIP_FLAG(0);
                }
        }
 }
@@ -1666,13 +1744,16 @@ TEST_P(TDMOutput, OutputRemoveCommitHandlerDifferentData)
                ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
 
                for (int t = 0; t < 10; t++) {
-                       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);
-                       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);
+                       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);
+                               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);
+                       } else
+                               TDM_UT_SKIP_FLAG(0);
                }
        }
 }
@@ -1692,12 +1773,15 @@ TEST_P(TDMOutput, OutputRemoveCommitHandlerInHandler)
                ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
 
                for (int t = 0; t < 10; t++) {
-                       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);
-                       while (!done1 || !done2 || !done3)
-                               ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+                       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);
+                               while (!done1 || !done2 || !done3)
+                                       ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+                       } else
+                               TDM_UT_SKIP_FLAG(0);
                }
        }
 }
@@ -1712,4 +1796,4 @@ INSTANTIATE_TEST_CASE_P(TDMOutputParams,
                                                Values(TDM_DEFAULT_MODULE));
 #endif
 
-/* LCOV_EXCL_END */
\ No newline at end of file
+/* LCOV_EXCL_END */