haltests: use EXPECT intead of ASSERT

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

diff --git a/haltests/src/tc_tdm_hwc.cpp b/haltests/src/tc_tdm_hwc.cpp
index 8307bed..869c9c2 100644 (file)
--- a/haltests/src/tc_tdm_hwc.cpp
+++ b/haltests/src/tc_tdm_hwc.cpp
@@ -74,8 +74,8 @@ TEST_P(TDMHwc, CreateWindowFailNull)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(NULL, tdm_hwc_create_window(NULL, &error));
-       ASSERT_NE(TDM_ERROR_NONE, error);
+       EXPECT_EQ(NULL, tdm_hwc_create_window(NULL, &error));
+       EXPECT_NE(TDM_ERROR_NONE, error);
 }
 
 TEST_P(TDMHwc, CreateWindowSuccessful)
@@ -90,11 +90,11 @@ TEST_P(TDMHwc, CreateWindowSuccessful)
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        hw = tdm_hwc_create_window(hwc, &error);
-                       ASSERT_EQ(TDM_ERROR_NONE, error);
+                       EXPECT_EQ(TDM_ERROR_NONE, error);
                        tdm_hwc_window_destroy(hw);
                } else {
-                       ASSERT_EQ(NULL, tdm_hwc_create_window(hwc, &error));
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_EQ(NULL, tdm_hwc_create_window(hwc, &error));
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                }
        }
 }
@@ -107,7 +107,7 @@ TEST_P(TDMHwc, GetSupportedFormatsFailNull)
        tdm_error error;
 
        error = tdm_hwc_get_video_supported_formats(NULL, NULL, NULL);
-       ASSERT_NE(TDM_ERROR_NONE, error);
+       EXPECT_NE(TDM_ERROR_NONE, error);
 }
 
 TEST_P(TDMHwc, GetSupportedFormatsSuccessful)
@@ -124,13 +124,13 @@ TEST_P(TDMHwc, GetSupportedFormatsSuccessful)
                if (hwc) {
                        error = tdm_hwc_get_video_supported_formats(hwc, &formats, &count);
                        if (error != TDM_ERROR_NOT_IMPLEMENTED) {
-                               ASSERT_EQ(TDM_ERROR_NONE, error);
+                               EXPECT_EQ(TDM_ERROR_NONE, error);
                                if (count > 0)
-                                       ASSERT_NE(NULL, formats);
+                                       EXPECT_NE(NULL, formats);
                        }
                } else {
                        error = tdm_hwc_get_video_supported_formats(hwc, &formats, &count);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                }
        }
 }
@@ -150,16 +150,16 @@ TEST_P(TDMHwc, GetAvailableVideoPropertiesFailNull)
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        error = tdm_hwc_get_video_available_properties(NULL, &props, &count);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
 
                        error = tdm_hwc_get_video_available_properties(hwc, NULL, &count);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
 
                        error = tdm_hwc_get_video_available_properties(hwc, &props, NULL);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                } else {
                        error = tdm_hwc_get_video_available_properties(hwc, &props, &count);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                }
        }
 }
@@ -177,10 +177,10 @@ TEST_P(TDMHwc, GetAvailableVideoPropertiesSuccess)
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        error = tdm_hwc_get_video_available_properties(hwc, &props, &count);
-                       ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
+                       EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
                } else {
                        error = tdm_hwc_get_video_available_properties(hwc, &props, &count);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                }
        }
 }
@@ -198,13 +198,13 @@ TEST_P(TDMHwc, GetAvailableCapabilitiesFailNull)
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        error = tdm_hwc_get_capabilities(NULL, &hwc_caps);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
 
                        error = tdm_hwc_get_capabilities(hwc, NULL);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                } else {
                        error = tdm_hwc_get_capabilities(hwc, &hwc_caps);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                }
        }
 }
@@ -221,10 +221,10 @@ TEST_P(TDMHwc, GetAvailableCapabilitiesSuccess)
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        error = tdm_hwc_get_capabilities(hwc, &hwc_caps);
-                       ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
+                       EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
                } else {
                        error = tdm_hwc_get_capabilities(hwc, &hwc_caps);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                }
        }
 }
@@ -243,16 +243,16 @@ TEST_P(TDMHwc, GetAvailablePropertiesFailNullWin)
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        error = tdm_hwc_get_available_properties(NULL, &props, &count);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
 
                        error = tdm_hwc_get_available_properties(hwc, NULL, &count);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
 
                        error = tdm_hwc_get_available_properties(hwc, &props, NULL);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                } else {
                        error = tdm_hwc_get_available_properties(hwc, &props, &count);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                }
        }
 }
@@ -270,10 +270,10 @@ TEST_P(TDMHwc, GetAvailablePropertiesSuccess)
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        error = tdm_hwc_get_available_properties(hwc, &props, &count);
-                       ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
+                       EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
                } else {
                        error = tdm_hwc_get_available_properties(hwc, &props, &count);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                }
        }
 
@@ -292,13 +292,13 @@ TEST_P(TDMHwc, GetClientTargetBufferQueueFailNullObject)
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        queue = tdm_hwc_get_client_target_buffer_queue(NULL, &error);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
-                       ASSERT_EQ(NULL, queue);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_EQ(NULL, queue);
 
                        queue = tdm_hwc_get_client_target_buffer_queue(NULL, NULL);
-                       ASSERT_EQ(NULL, queue);
+                       EXPECT_EQ(NULL, queue);
                } else {
-                       ASSERT_EQ(NULL, queue);
+                       EXPECT_EQ(NULL, queue);
                }
        }
 }
@@ -315,12 +315,12 @@ TEST_P(TDMHwc, GetClientTargetBufferQueueFailNoHwc)
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
-                       ASSERT_EQ(NULL, queue);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_EQ(NULL, queue);
                } else {
                        queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
-                       ASSERT_EQ(NULL, queue);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_EQ(NULL, queue);
                }
        }
 }
@@ -334,26 +334,26 @@ TEST_P(TDMHwc, GetClientTargetBufferQueueSuccessful)
        tbm_surface_queue_h queue = NULL;
 
        for (int o = 0; o < output_count; o++) {
-               ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+               EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
                        tbm_surface_queue_destroy(queue);
-                       ASSERT_EQ(TDM_ERROR_NONE, error);
-                       ASSERT_NE(NULL, queue);
+                       EXPECT_EQ(TDM_ERROR_NONE, error);
+                       EXPECT_NE(NULL, queue);
 
                        queue = tdm_hwc_get_client_target_buffer_queue(hwc, NULL);
                        tbm_surface_queue_destroy(queue);
-                       ASSERT_EQ(TDM_ERROR_NONE, error);
-                       ASSERT_NE(NULL, queue);
+                       EXPECT_EQ(TDM_ERROR_NONE, error);
+                       EXPECT_NE(NULL, queue);
                } else {
                        queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
-                       ASSERT_EQ(NULL, queue);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_EQ(NULL, queue);
 
                        queue = tdm_hwc_get_client_target_buffer_queue(hwc, NULL);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
-                       ASSERT_EQ(NULL, queue);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_EQ(NULL, queue);
                }
        }
 }
@@ -368,11 +368,11 @@ TEST_P(TDMHwc, SetClientTargetBufferFailNullOutput)
 
        target_buff = tbm_surface_internal_create_with_flags(720, 1024,
                                                                        TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
-       ASSERT_NE(NULL, target_buff);
+       EXPECT_NE(NULL, target_buff);
 
        error = tdm_hwc_set_client_target_buffer(NULL, target_buff, damage);
        tbm_surface_internal_destroy(target_buff);
-       ASSERT_NE(TDM_ERROR_NONE, error);
+       EXPECT_NE(TDM_ERROR_NONE, error);
 }
 
 TEST_P(TDMHwc, SetClientTargetBufferSuccessfulSetBuff)
@@ -386,21 +386,21 @@ TEST_P(TDMHwc, SetClientTargetBufferSuccessfulSetBuff)
        tbm_surface_h target_buff = NULL;
 
        for (int o = 0; o < output_count; o++) {
-               ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+               EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
-                       ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
-                       ASSERT_NE(mode, NULL);
+                       EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
+                       EXPECT_NE(mode, NULL);
                        target_buff = tbm_surface_internal_create_with_flags(mode->hdisplay, mode->vdisplay,
                                                                        TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
-                       ASSERT_NE(NULL, target_buff);
+                       EXPECT_NE(NULL, target_buff);
 
                        error = tdm_hwc_set_client_target_buffer(hwc, target_buff, damage);
                        tbm_surface_internal_destroy(target_buff);
-                       ASSERT_EQ(TDM_ERROR_NONE, error);
+                       EXPECT_EQ(TDM_ERROR_NONE, error);
                } else {
                        error = tdm_hwc_set_client_target_buffer(hwc, target_buff, damage);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                }
        }
 }
@@ -414,14 +414,14 @@ TEST_P(TDMHwc, SetClientTargetBufferSuccessfulResetBuff)
        tdm_region damage = {.num_rects = 0, .rects = NULL};
 
        for (int o = 0; o < output_count; o++) {
-               ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+               EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        error = tdm_hwc_set_client_target_buffer(hwc, NULL, damage);
-                       ASSERT_EQ(TDM_ERROR_NONE, error);
+                       EXPECT_EQ(TDM_ERROR_NONE, error);
                } else {
                        error = tdm_hwc_set_client_target_buffer(hwc, NULL, damage);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                }
        }
 }
@@ -436,16 +436,16 @@ TEST_P(TDMHwc, ValidateFailNull)
        uint32_t num_types;
 
        error = tdm_hwc_validate(NULL, NULL, 0, &num_types);
-       ASSERT_NE(TDM_ERROR_NONE, error);
+       EXPECT_NE(TDM_ERROR_NONE, error);
 
        for (int o = 0; o < output_count; o++) {
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        error = tdm_hwc_validate(hwc, NULL, 0, NULL);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                } else {
                        error = tdm_hwc_validate(hwc, NULL, 0, NULL);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                }
        }
 }
@@ -460,16 +460,16 @@ TEST_P(TDMHwc, GetChangedCompositionTypesFailNull)
        uint32_t num_elements;
 
        error = tdm_hwc_get_changed_composition_types(NULL, &num_elements, NULL, NULL);
-       ASSERT_NE(TDM_ERROR_NONE, error);
+       EXPECT_NE(TDM_ERROR_NONE, error);
 
        for (int o = 0; o < output_count; o++) {
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        error = tdm_hwc_get_changed_composition_types(hwc, NULL, NULL, NULL);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                } else {
                        error = tdm_hwc_get_changed_composition_types(hwc, NULL, NULL, NULL);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                }
        }
 }
@@ -480,7 +480,7 @@ TEST_P(TDMHwc, AcceptChangesFailNull)
        TDM_UT_SKIP_FLAG(has_outputs);
 
        error = tdm_hwc_accept_validation(NULL);
-       ASSERT_NE(TDM_ERROR_NONE, error);
+       EXPECT_NE(TDM_ERROR_NONE, error);
 }
 
 TEST_P(TDMHwc, AcceptChangesFailNoHwc)
@@ -492,10 +492,10 @@ TEST_P(TDMHwc, AcceptChangesFailNoHwc)
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        error = tdm_hwc_accept_validation(hwc);
-                       ASSERT_EQ(TDM_ERROR_NONE, error);
+                       EXPECT_EQ(TDM_ERROR_NONE, error);
                } else {
                        error = tdm_hwc_accept_validation(hwc);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                }
        }
 }
@@ -513,18 +513,18 @@ TEST_P(TDMHwc, AcceptChangesSuccessful)
        uint32_t get_num = 0;
 
        for (int o = 0; o < output_count; o++) {
-               ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+               EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        for (int w = 0; w < HWC_WIN_NUM; w++) {
                                hwc_wnds[w] = tdm_hwc_create_window(hwc, &error);
-                               ASSERT_EQ(TDM_ERROR_NONE, error);
+                               EXPECT_EQ(TDM_ERROR_NONE, error);
                                error = tdm_hwc_window_set_composition_type(hwc_wnds[w], TDM_HWC_WIN_COMPOSITION_DEVICE);
-                               ASSERT_EQ(TDM_ERROR_NONE, error);
+                               EXPECT_EQ(TDM_ERROR_NONE, error);
                        }
 
                        error = tdm_hwc_validate(hwc, hwc_wnds, HWC_WIN_NUM, &num_types);
-                       ASSERT_EQ(TDM_ERROR_NONE, error);
+                       EXPECT_EQ(TDM_ERROR_NONE, error);
 
                        if (num_types > 0) {
                                changed_hwc_window = (tdm_hwc_window **)calloc(num_types, sizeof(tdm_hwc_window *));
@@ -532,11 +532,11 @@ TEST_P(TDMHwc, AcceptChangesSuccessful)
 
                                get_num = num_types;
                                error = tdm_hwc_get_changed_composition_types(hwc, &get_num, changed_hwc_window, composition_types);
-                               ASSERT_EQ(TDM_ERROR_NONE, error);
-                               ASSERT_EQ(get_num, num_types);
+                               EXPECT_EQ(TDM_ERROR_NONE, error);
+                               EXPECT_EQ(get_num, num_types);
 
                                error = tdm_hwc_accept_validation(hwc);
-                               ASSERT_EQ(TDM_ERROR_NONE, error);
+                               EXPECT_EQ(TDM_ERROR_NONE, error);
 
                                free(composition_types);
                                free(changed_hwc_window);
@@ -545,7 +545,7 @@ TEST_P(TDMHwc, AcceptChangesSuccessful)
                        for (int w = 0; w < HWC_WIN_NUM; w++)
                                tdm_hwc_window_destroy(hwc_wnds[w]);
 
-                               ASSERT_EQ(TDM_ERROR_NONE, error);
+                               EXPECT_EQ(TDM_ERROR_NONE, error);
                        }
        }
 }
@@ -556,7 +556,7 @@ TEST_P(TDMHwc, CommitFailNull)
        TDM_UT_SKIP_FLAG(has_outputs);
 
        error = tdm_hwc_commit(NULL, 1, NULL, NULL);
-       ASSERT_NE(TDM_ERROR_NONE, error);
+       EXPECT_NE(TDM_ERROR_NONE, error);
 }
 
 TEST_P(TDMHwc, CommitSuccessful)
@@ -572,18 +572,18 @@ TEST_P(TDMHwc, CommitSuccessful)
        uint32_t get_num = 0;
 
        for (int o = 0; o < output_count; o++) {
-               ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+               EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        for (int w = 0; w < HWC_WIN_NUM; w++) {
                                hwc_wnds[w] = tdm_hwc_create_window(hwc, &error);
-                               ASSERT_EQ(TDM_ERROR_NONE, error);
+                               EXPECT_EQ(TDM_ERROR_NONE, error);
                                error = tdm_hwc_window_set_composition_type(hwc_wnds[w], TDM_HWC_WIN_COMPOSITION_DEVICE);
-                               ASSERT_EQ(TDM_ERROR_NONE, error);
+                               EXPECT_EQ(TDM_ERROR_NONE, error);
                        }
 
                        error = tdm_hwc_validate(hwc, hwc_wnds, HWC_WIN_NUM, &num_types);
-                       ASSERT_EQ(TDM_ERROR_NONE, error);
+                       EXPECT_EQ(TDM_ERROR_NONE, error);
 
                        if (num_types > 0) {
                                changed_hwc_window = (tdm_hwc_window **)calloc(num_types, sizeof(tdm_hwc_window *));
@@ -591,23 +591,23 @@ TEST_P(TDMHwc, CommitSuccessful)
 
                                get_num = num_types;
                                error = tdm_hwc_get_changed_composition_types(hwc, &get_num, changed_hwc_window, composition_types);
-                               ASSERT_EQ(TDM_ERROR_NONE, error);
-                               ASSERT_EQ(get_num, num_types);
+                               EXPECT_EQ(TDM_ERROR_NONE, error);
+                               EXPECT_EQ(get_num, num_types);
 
                                error =  tdm_hwc_accept_validation(hwc);
-                               ASSERT_EQ(TDM_ERROR_NONE, error);
+                               EXPECT_EQ(TDM_ERROR_NONE, error);
 
                                free(composition_types);
                                free(changed_hwc_window);
                        }
 
                        error = tdm_hwc_commit(hwc, 0, _tc_tdm_hwc_commit_cb, NULL);
-                       ASSERT_EQ(TDM_ERROR_NONE, error);
+                       EXPECT_EQ(TDM_ERROR_NONE, error);
 
                        for (int w = 0; w < HWC_WIN_NUM; w++)
                                tdm_hwc_window_destroy(hwc_wnds[w]);
 
-                               ASSERT_EQ(TDM_ERROR_NONE, error);
+                               EXPECT_EQ(TDM_ERROR_NONE, error);
                        }
        }
 }
@@ -627,10 +627,10 @@ TEST_P(TDMHwc, SetPropertyFailNull)
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        error = tdm_hwc_set_property(NULL, 0, value);
-                       ASSERT_EQ(TDM_ERROR_INVALID_PARAMETER, error);
+                       EXPECT_EQ(TDM_ERROR_INVALID_PARAMETER, error);
                } else {
                        error = tdm_hwc_set_property(hwc, 0, value);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                }
        }
 }
@@ -651,18 +651,18 @@ TEST_P(TDMHwc, SetPropertySuccess)
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        error = tdm_hwc_get_available_properties(hwc, &props, &count);
-                       ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
+                       EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
 
                        if (count == 0) {
                                error = tdm_hwc_set_property(hwc, 0, value);
-                               ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
+                               EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
                        } else {
                                error = tdm_hwc_set_property(hwc, props[0].id, value);
-                               ASSERT_EQ(TDM_ERROR_NONE, error);
+                               EXPECT_EQ(TDM_ERROR_NONE, error);
                        }
                } else {
                        error = tdm_hwc_set_property(hwc, 0, value);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                }
        }
 }
@@ -680,10 +680,10 @@ TEST_P(TDMHwc, GetPropertyFailNull)
                hwc = tdm_output_get_hwc(outputs[o], &error);
                if (hwc) {
                        error = tdm_hwc_get_property(NULL, 0, &value);
-                       ASSERT_EQ(TDM_ERROR_INVALID_PARAMETER, error);
+                       EXPECT_EQ(TDM_ERROR_INVALID_PARAMETER, error);
                } else {
                        error = tdm_hwc_get_property(hwc, 0, &value);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                }
        }
 }
@@ -703,18 +703,18 @@ TEST_P(TDMHwc, GetPropertySuccess)
 
                if (hwc) {
                        error = tdm_hwc_get_available_properties(hwc, &props, &count);
-                       ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
+                       EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
 
                        if (count == 0) {
                                error = tdm_hwc_get_property(hwc, 0, &value);
-                               ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
+                               EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
                        } else {
                                error = tdm_hwc_get_property(hwc, props[0].id, &value);
-                               ASSERT_EQ(TDM_ERROR_NONE, error);
+                               EXPECT_EQ(TDM_ERROR_NONE, error);
                        }
                } else {
                        error = tdm_hwc_get_property(hwc, 0, &value);
-                       ASSERT_NE(TDM_ERROR_NONE, error);
+                       EXPECT_NE(TDM_ERROR_NONE, error);
                }
        }
 }