haltests: use EXPECT intead of ASSERT

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

diff --git a/haltests/src/tc_tdm_client.cpp b/haltests/src/tc_tdm_client.cpp
index d107b20..1856692 100644 (file)
--- a/haltests/src/tc_tdm_client.cpp
+++ b/haltests/src/tc_tdm_client.cpp
@@ -107,7 +107,7 @@ void TDMClient::ServerFork(void)
                return;
 
        server_pid = _tc_tdm_client_server_fork(pipe_parent, pipe_child);
-       ASSERT_GT(server_pid, 0);
+       EXPECT_GT(server_pid, 0);
 }
 
 void TDMClient::ServerKill(void)
@@ -515,14 +515,14 @@ TEST_P(TDMClient, ClientCreate)
        tdm_error ret;
 
        client = tdm_client_create(&ret);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
-       ASSERT_NE(client, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_NE(client, NULL);
 }
 
 TEST_P(TDMClient, ClientCreateNullOther)
 {
        client = tdm_client_create(NULL);
-       ASSERT_NE(client, NULL);
+       EXPECT_NE(client, NULL);
 }
 
 TEST_P(TDMClient, ClientDestroy)
@@ -530,8 +530,8 @@ TEST_P(TDMClient, ClientDestroy)
        tdm_error ret;
 
        client = tdm_client_create(&ret);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
-       ASSERT_NE(client, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_NE(client, NULL);
 
        tdm_client_destroy(client);
        client = NULL;
@@ -547,24 +547,24 @@ TEST_P(TDMClient, ClientGetFd)
 {
        int fd = TDM_UT_INVALID_VALUE;
 
-       ASSERT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareClient(), true);
 
-       ASSERT_EQ(tdm_client_get_fd(client, &fd), TDM_ERROR_NONE);
-       ASSERT_GE(fd, 0);
+       EXPECT_EQ(tdm_client_get_fd(client, &fd), TDM_ERROR_NONE);
+       EXPECT_GE(fd, 0);
 }
 
 TEST_P(TDMClient, ClientGetFdNullObject)
 {
        int fd = TDM_UT_INVALID_VALUE;
-       ASSERT_EQ(tdm_client_get_fd(NULL, &fd), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(fd, TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_client_get_fd(NULL, &fd), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(fd, TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMClient, ClientGetFdNullOther)
 {
-       ASSERT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareClient(), true);
 
-       ASSERT_EQ(tdm_client_get_fd(client, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_client_get_fd(client, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 static void
@@ -580,18 +580,18 @@ TEST_P(TDMClient, ClientHandleEvent)
 {
        bool done = false;
 
-       ASSERT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareClient(), true);
 
-       ASSERT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _tc_tdm_client_vblank_cb, &done), TDM_ERROR_NONE);
-       ASSERT_EQ(done, false);
+       EXPECT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _tc_tdm_client_vblank_cb, &done), TDM_ERROR_NONE);
+       EXPECT_EQ(done, false);
 
        while (!done)
-               ASSERT_EQ(tdm_client_handle_events(client), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_handle_events(client), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMClient, ClientHandleEventNullObject)
 {
-       ASSERT_EQ(tdm_client_handle_events(NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_client_handle_events(NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 /* tdm_client_wait_vblank, deprecated */
@@ -599,13 +599,13 @@ TEST_P(TDMClient, ClientWaitVblank)
 {
        bool done = false;
 
-       ASSERT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareClient(), true);
 
-       ASSERT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _tc_tdm_client_vblank_cb, &done), TDM_ERROR_NONE);
-       ASSERT_EQ(done, false);
+       EXPECT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _tc_tdm_client_vblank_cb, &done), TDM_ERROR_NONE);
+       EXPECT_EQ(done, false);
 
        while (!done)
-               ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
 }
 
 /* tdm_client_get_output */
@@ -613,44 +613,44 @@ TEST_P(TDMClient, ClientGetOutput)
 {
        tdm_error ret;
 
-       ASSERT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareClient(), true);
 
        output = tdm_client_get_output(client, NULL, &ret);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
-       ASSERT_NE(output, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_NE(output, NULL);
 }
 
 TEST_P(TDMClient, ClientGetOutputPrimary)
 {
        tdm_error ret;
 
-       ASSERT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareClient(), true);
 
        output = tdm_client_get_output(client, (char*)"primary", &ret);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
-       ASSERT_NE(output, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_NE(output, NULL);
 }
 
 TEST_P(TDMClient, ClientGetOutputDefault)
 {
        tdm_error ret;
 
-       ASSERT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareClient(), true);
 
        output = tdm_client_get_output(client, (char*)"default", &ret);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
-       ASSERT_NE(output, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_NE(output, NULL);
 }
 
 TEST_P(TDMClient, ClientGetOutputInvalidName)
 {
        tdm_error ret;
 
-       ASSERT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareClient(), true);
 
        output = tdm_client_get_output(client, (char*)"invalid", &ret);
-       ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(output, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(output, NULL);
 }
 
 TEST_P(TDMClient, ClientGetOutputNullObject)
@@ -658,16 +658,16 @@ TEST_P(TDMClient, ClientGetOutputNullObject)
        tdm_error ret;
 
        output = tdm_client_get_output(NULL, NULL, &ret);
-       ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(output, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(output, NULL);
 }
 
 TEST_P(TDMClient, ClientGetOutputNullOther)
 {
-       ASSERT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareClient(), true);
 
        output = tdm_client_get_output(client, NULL, NULL);
-       ASSERT_NE(output, NULL);
+       EXPECT_NE(output, NULL);
 }
 
 static void
@@ -694,54 +694,54 @@ TEST_P(TDMClient, ClientOutputAddChangeHandler)
        bool done = false;
        tdm_output_dpms dpms;
 
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
 
-       ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE);
-       ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
+       EXPECT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE);
+       EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
 
        while (!done)
-               ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
 
-       ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
-       ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF);
+       EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+       EXPECT_EQ(dpms, TDM_OUTPUT_DPMS_OFF);
 
-       ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
+       EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
        while (dpms != TDM_OUTPUT_DPMS_ON) {
-               ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
-               ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
        }
 }
 
 TEST_P(TDMClient, ClientOutputAddChangeHandlerTwice)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
 
-       ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE);
-       ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_BAD_REQUEST);
+       EXPECT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_BAD_REQUEST);
 }
 
 TEST_P(TDMClient, ClientOutputAddChangeHandlerNullObject)
 {
-       ASSERT_EQ(tdm_client_output_add_change_handler(NULL, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_client_output_add_change_handler(NULL, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMClient, ClientOutputAddChangeHandlerNullOther)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
 
-       ASSERT_EQ(tdm_client_output_add_change_handler(output, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_client_output_add_change_handler(output, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 /* tdm_client_output_remove_change_handler */
 TEST_P(TDMClient, ClientOutputRemoveChangeHandler)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
 
-       ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE);
        tdm_client_output_remove_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL);
 }
 
@@ -749,10 +749,10 @@ TEST_P(TDMClient, ClientOutputRemoveChangeHandlerDifferentData)
 {
        bool done = (bool)TDM_UT_INVALID_VALUE;
 
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
 
-       ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE);
        tdm_client_output_remove_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL);
 }
 
@@ -775,20 +775,20 @@ TEST_P(TDMClient, ClientOutputRemoveChangeHandlerInHandler)
 {
        tdm_output_dpms dpms = TDM_OUTPUT_DPMS_ON;
 
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
 
-       ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb2, NULL), TDM_ERROR_NONE);
-       ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
-       ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb2, NULL), TDM_ERROR_NONE);
+       EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
+       EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
        while (dpms != TDM_OUTPUT_DPMS_OFF) {
-               ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
-               ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
        }
 
-       ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
+       EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
        while (dpms != TDM_OUTPUT_DPMS_ON)
-               ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullObject)
@@ -798,8 +798,8 @@ TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullObject)
 
 TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullOther)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
 
        tdm_client_output_remove_change_handler(output, NULL, NULL);
 }
@@ -809,27 +809,27 @@ TEST_P(TDMClient, ClientOutputGetRefreshRate)
 {
        unsigned int refresh = 0;
 
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
 
-       ASSERT_EQ(tdm_client_output_get_refresh_rate(output, &refresh), TDM_ERROR_NONE);
-       ASSERT_GT(refresh, 0);
+       EXPECT_EQ(tdm_client_output_get_refresh_rate(output, &refresh), TDM_ERROR_NONE);
+       EXPECT_GT(refresh, 0);
 }
 
 TEST_P(TDMClient, ClientOutputGetRefreshRateNullObject)
 {
        unsigned int refresh = (unsigned int)TDM_UT_INVALID_VALUE;
 
-       ASSERT_EQ(tdm_client_output_get_refresh_rate(NULL, &refresh), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(refresh, (unsigned int)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_client_output_get_refresh_rate(NULL, &refresh), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(refresh, (unsigned int)TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMClient, ClientOutputGetRefreshRateNullOther)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
 
-       ASSERT_EQ(tdm_client_output_get_refresh_rate(output, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_client_output_get_refresh_rate(output, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 /* tdm_client_output_get_mode */
@@ -837,12 +837,12 @@ TEST_P(TDMClient, ClientOutputGetMode)
 {
        unsigned int width = 0, height = 0;
 
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
 
-       ASSERT_EQ(tdm_client_output_get_mode(output, &width, &height), TDM_ERROR_NONE);
-       ASSERT_GT(width, 0);
-       ASSERT_GT(height, 0);
+       EXPECT_EQ(tdm_client_output_get_mode(output, &width, &height), TDM_ERROR_NONE);
+       EXPECT_GT(width, 0);
+       EXPECT_GT(height, 0);
 }
 
 TEST_P(TDMClient, ClientOutputGetModeNullObject)
@@ -850,17 +850,17 @@ TEST_P(TDMClient, ClientOutputGetModeNullObject)
        unsigned int width = (unsigned int)TDM_UT_INVALID_VALUE;
        unsigned int height = (unsigned int)TDM_UT_INVALID_VALUE;
 
-       ASSERT_EQ(tdm_client_output_get_mode(NULL, &width, &height), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(width, (unsigned int)TDM_UT_INVALID_VALUE);
-       ASSERT_EQ(height, (unsigned int)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_client_output_get_mode(NULL, &width, &height), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(width, (unsigned int)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(height, (unsigned int)TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMClient, ClientOutputGetModeNullOther)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
 
-       ASSERT_EQ(tdm_client_output_get_mode(output, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_client_output_get_mode(output, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 /* tdm_client_output_get_conn_status */
@@ -868,27 +868,27 @@ TEST_P(TDMClient, ClientOutputGetConnStatus)
 {
        tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE;
 
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
 
-       ASSERT_EQ(tdm_client_output_get_conn_status(output, &status), TDM_ERROR_NONE);
-       ASSERT_NE(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_client_output_get_conn_status(output, &status), TDM_ERROR_NONE);
+       EXPECT_NE(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMClient, ClientOutputGetConnStatusNullObject)
 {
        tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE;
 
-       ASSERT_EQ(tdm_client_output_get_conn_status(NULL, &status), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_client_output_get_conn_status(NULL, &status), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMClient, ClientOutputGetConnStatusNullOther)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
 
-       ASSERT_EQ(tdm_client_output_get_conn_status(output, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_client_output_get_conn_status(output, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 /* tdm_client_output_get_dpms */
@@ -896,27 +896,27 @@ TEST_P(TDMClient, ClientOutputGetDpms)
 {
        tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
 
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
 
-       ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
-       ASSERT_NE(dpms, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+       EXPECT_NE(dpms, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMClient, ClientOutputGetDpmsNullObject)
 {
        tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
 
-       ASSERT_EQ(tdm_client_output_get_dpms(NULL, &dpms), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(dpms, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_client_output_get_dpms(NULL, &dpms), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(dpms, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMClient, ClientOutputGetDpmsNullOther)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
 
-       ASSERT_EQ(tdm_client_output_get_dpms(output, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_client_output_get_dpms(output, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 /* tdm_client_output_create_vblank */
@@ -924,12 +924,12 @@ TEST_P(TDMClient, ClientOutputCreateVblank)
 {
        tdm_error ret;
 
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
 
        vblank = tdm_client_output_create_vblank(output, &ret);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
-       ASSERT_NE(vblank, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_NE(vblank, NULL);
 }
 
 TEST_P(TDMClient, ClientOutputCreateVblankNullObject)
@@ -937,17 +937,17 @@ TEST_P(TDMClient, ClientOutputCreateVblankNullObject)
        tdm_error ret;
 
        vblank = tdm_client_output_create_vblank(NULL, &ret);
-       ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(vblank, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(vblank, NULL);
 }
 
 TEST_P(TDMClient, ClientOutputCreateVblankNullOther)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
 
        vblank = tdm_client_output_create_vblank(output, NULL);
-       ASSERT_NE(vblank, NULL);
+       EXPECT_NE(vblank, NULL);
 }
 
 /* tdm_client_vblank_destroy */
@@ -955,12 +955,12 @@ TEST_P(TDMClient, ClientVblankDestroy)
 {
        tdm_error ret;
 
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
 
        vblank = tdm_client_output_create_vblank(output, &ret);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
-       ASSERT_NE(vblank, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_NE(vblank, NULL);
 
        tdm_client_vblank_destroy(vblank);
        vblank = NULL;
@@ -974,126 +974,126 @@ TEST_P(TDMClient, ClientVblankDestroyNullObject)
 /* tdm_client_vblank_set_name */
 TEST_P(TDMClient, ClientVblankSetName)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
-       ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMClient, ClientVblankSetNameTwice)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
-       ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
-       ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMClient, ClientVblankSetNameNullObject)
 {
-       ASSERT_EQ(tdm_client_vblank_set_name(NULL, TDM_UT_VBLANK_NAME), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_client_vblank_set_name(NULL, TDM_UT_VBLANK_NAME), TDM_ERROR_INVALID_PARAMETER);
 }
 
 /* tdm_client_vblank_set_sync */
 TEST_P(TDMClient, ClientVblankSetSync)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
-       ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMClient, ClientVblankSetSyncTwice)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
-       ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
-       ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMClient, ClientVblankSetSyncNullObject)
 {
-       ASSERT_EQ(tdm_client_vblank_set_sync(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_client_vblank_set_sync(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
 }
 
 /* tdm_client_vblank_set_fps */
 TEST_P(TDMClient, ClientVblankSetFps)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
-       ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMClient, ClientVblankSetFpsTwice)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
-       ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
-       ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMClient, ClientVblankSetFpsNullObject)
 {
-       ASSERT_EQ(tdm_client_vblank_set_fps(NULL, 30), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_client_vblank_set_fps(NULL, 30), TDM_ERROR_INVALID_PARAMETER);
 }
 
 /* tdm_client_vblank_set_offset */
 TEST_P(TDMClient, ClientVblankSetOffset)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
-       ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMClient, ClientVblankSetOffsetTwice)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
-       ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
-       ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMClient, ClientVblankSetOffsetNullObject)
 {
-       ASSERT_EQ(tdm_client_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_client_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER);
 }
 
 /* tdm_client_vblank_set_enable_fake */
 TEST_P(TDMClient, ClientVblankSetEnableFake)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
-       ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMClient, ClientVblankSetEnableFakeTwice)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
-       ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
-       ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMClient, ClientVblankSetEnableFakeNullObject)
 {
-       ASSERT_EQ(tdm_client_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_client_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
 }
 
 static void
@@ -1114,75 +1114,75 @@ TEST_P(TDMClient, ClientVblankWait)
 {
        bool done;
 
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
        done = false;
-       ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
 
        start = tdm_helper_get_time();
        while (!done)
-               ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
        end = tdm_helper_get_time();
 
        /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
-       ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
+       EXPECT_LT((end - start), (vrefresh_interval + vrefresh_interval));
 }
 
 TEST_P(TDMClient, ClientVblankWaitFewTime)
 {
        bool done1, done2, done3;
 
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
        done1 = done2 = done3 = false;
-       ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done1), TDM_ERROR_NONE);
-       ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done2), TDM_ERROR_NONE);
-       ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done3), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done1), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done2), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done3), TDM_ERROR_NONE);
 
        start = tdm_helper_get_time();
        while (!done1 || !done2 || !done3)
-               ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
        end = tdm_helper_get_time();
 
        /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
-       ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
+       EXPECT_LT((end - start), (vrefresh_interval + vrefresh_interval));
 
 }
 
 TEST_P(TDMClient, ClientVblankWaitInterval0)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
-       ASSERT_EQ(tdm_client_vblank_wait(vblank, 0, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_client_vblank_wait(vblank, 0, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMClient, ClientVblankWaitInterval)
 {
        bool done;
 
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
        /* start from 1 */
        for (int t = 1; t < 10; t++) {
                done = false;
-               ASSERT_EQ(tdm_client_vblank_wait(vblank, t, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_vblank_wait(vblank, t, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
 
                start = tdm_helper_get_time();
                while (!done)
-                       ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+                       EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
                end = tdm_helper_get_time();
 
                /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
-               ASSERT_GT((end - start), (vrefresh_interval * (t - 1)));
-               ASSERT_LT((end - start), (vrefresh_interval * t + vrefresh_interval));
+               EXPECT_GT((end - start), (vrefresh_interval * (t - 1)));
+               EXPECT_LT((end - start), (vrefresh_interval * t + vrefresh_interval));
        }
 }
 
@@ -1201,51 +1201,51 @@ _tc_tdm_client_vblank_cb3(tdm_client_vblank *vblank,
 
 TEST_P(TDMClient, ClientVblankWaitSeq)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
        for (int t = 0; t < 10; t++) {
                unsigned int cur_seq = 0, temp = 0;
 
-               ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE);
                while (cur_seq == 0)
-                       ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+                       EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
 
                start = tdm_helper_get_time();
-               ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + 1, _tc_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + 1, _tc_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE);
                while (temp == 0)
-                       ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+                       EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
                end = tdm_helper_get_time();
 
                /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
-               ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
+               EXPECT_LT((end - start), (vrefresh_interval + vrefresh_interval));
        }
 }
 
 TEST_P(TDMClient, ClientVblankWaitSeqInterval)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
        /* start from 1 */
        for (int t = 1; t < 10; t++) {
                unsigned int cur_seq = 0, temp = 0;
 
-               ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE);
                while (cur_seq == 0)
-                       ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+                       EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
 
                start = tdm_helper_get_time();
-               ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + t, _tc_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + t, _tc_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE);
                while (temp == 0)
-                       ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+                       EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
                end = tdm_helper_get_time();
 
                /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
-               ASSERT_GT((end - start), (vrefresh_interval * (t - 1)));
-               ASSERT_LT((end - start), (vrefresh_interval * t + vrefresh_interval));
+               EXPECT_GT((end - start), (vrefresh_interval * (t - 1)));
+               EXPECT_LT((end - start), (vrefresh_interval * t + vrefresh_interval));
        }
 }
 
@@ -1253,23 +1253,23 @@ TEST_P(TDMClient, ClientVblankWaitSetOffset)
 {
        bool done;
 
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
-       ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 100), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_set_offset(vblank, 100), TDM_ERROR_NONE);
 
        done = false;
-       ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
 
        start = tdm_helper_get_time();
        while (!done)
-               ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
        end = tdm_helper_get_time();
 
        /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
-       ASSERT_GT((end - start), (0.1));
-       ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval + 0.1));
+       EXPECT_GT((end - start), (0.1));
+       EXPECT_LT((end - start), (vrefresh_interval + vrefresh_interval + 0.1));
 }
 
 TEST_P(TDMClient, ClientVblankWaitSetFps)
@@ -1278,24 +1278,24 @@ TEST_P(TDMClient, ClientVblankWaitSetFps)
        double interval;
        unsigned int fps = 10;
 
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
-       ASSERT_EQ(tdm_client_vblank_set_fps(vblank, fps), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_set_fps(vblank, fps), TDM_ERROR_NONE);
        interval = 1.0 / (double)fps;
 
        done = false;
-       ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
 
        start = tdm_helper_get_time();
        while (!done)
-               ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
        end = tdm_helper_get_time();
 
        /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
-       ASSERT_GT((end - start), (interval - vrefresh_interval * 2));
-       ASSERT_LT((end - start), (interval + vrefresh_interval));
+       EXPECT_GT((end - start), (interval - vrefresh_interval * 2));
+       EXPECT_LT((end - start), (interval + vrefresh_interval));
 }
 
 #if 0
@@ -1310,16 +1310,16 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps)
        unsigned int global_fps = 5;
        double start, end, interval;
 
-       ASSERT_EQ(TestPrepareOutput(), true);
-       ASSERT_EQ(TestCreateVblanks3(), true);
-       ASSERT_EQ(vblank_count, 3);
+       EXPECT_EQ(TestPrepareOutput(), true);
+       EXPECT_EQ(TestCreateVblanks3(), true);
+       EXPECT_EQ(vblank_count, 3);
 
-       ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE);
-       ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE);
+       EXPECT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
        vrefresh_interval = 1.0 / (double)fps;
 
        for (int v = 0; v < 3; v++)
-               ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)), TDM_ERROR_NONE);
 
        /* enable test */
        tdm_vblank_enable_global_fps(1, global_fps);
@@ -1327,37 +1327,37 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps)
 
        for (int v = 0; v < 3; v++) {
                cur_seq[v] = 0;
-               ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
        }
 
        start = tdm_helper_get_time();
        while (cur_seq[0] == 0)
-               ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+               EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
        end = tdm_helper_get_time();
 
-       ASSERT_NE(cur_seq[1], 0);
-       ASSERT_NE(cur_seq[2], 0);
+       EXPECT_NE(cur_seq[1], 0);
+       EXPECT_NE(cur_seq[2], 0);
 
        /* "+- vrefresh_interval" consider the delay of socket communication between kernel and platform */
-       ASSERT_GT((end - start), (interval - vrefresh_interval));
-       ASSERT_LT((end - start), (interval + vrefresh_interval));
+       EXPECT_GT((end - start), (interval - vrefresh_interval));
+       EXPECT_LT((end - start), (interval + vrefresh_interval));
 
        /* disable test */
        tdm_vblank_enable_global_fps(0, 0);
 
        for (int v = 0; v < 3; v++) {
                cur_seq[v] = 0;
-               ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
        }
 
        while (cur_seq[0] == 0)
-               ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
-       ASSERT_EQ(cur_seq[1], 0);
-       ASSERT_EQ(cur_seq[2], 0);
+               EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+       EXPECT_EQ(cur_seq[1], 0);
+       EXPECT_EQ(cur_seq[2], 0);
 
        while (cur_seq[1] == 0)
-               ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
-       ASSERT_EQ(cur_seq[2], 0);
+               EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+       EXPECT_EQ(cur_seq[2], 0);
 }
 
 TEST_P(TDMVblank, VblankWaitIgnoreGlobalFps)
@@ -1369,38 +1369,38 @@ TEST_P(TDMVblank, VblankWaitIgnoreGlobalFps)
        unsigned int global_fps = 5;
        double start, end, interval;
 
-       ASSERT_EQ(TestPrepareOutput(), true);
-       ASSERT_EQ(TestCreateVblanks3(), true);
-       ASSERT_EQ(vblank_count, 3);
+       EXPECT_EQ(TestPrepareOutput(), true);
+       EXPECT_EQ(TestCreateVblanks3(), true);
+       EXPECT_EQ(vblank_count, 3);
 
-       ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE);
-       ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE);
+       EXPECT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
        interval = 1.0 / (double)fps;
 
        /* 2nd vblank will ignore the global fps. */
-       ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[1], 1), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_vblank_ignore_global_fps(vblanks[1], 1), TDM_ERROR_NONE);
 
        tdm_vblank_enable_global_fps(1, global_fps);
 
        for (int v = 0; v < 3; v++) {
                cur_seq[v] = 0;
-               ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
        }
 
        start = tdm_helper_get_time();
        while (cur_seq[1] == 0)
-               ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+               EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
        end = tdm_helper_get_time();
 
-       ASSERT_EQ(cur_seq[0], 0);
-       ASSERT_EQ(cur_seq[2], 0);
+       EXPECT_EQ(cur_seq[0], 0);
+       EXPECT_EQ(cur_seq[2], 0);
 
        /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
-       ASSERT_LT((end - start), (interval + interval));
+       EXPECT_LT((end - start), (interval + interval));
 
        while (cur_seq[0] == 0)
-               ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
-       ASSERT_NE(cur_seq[2], 0);
+               EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+       EXPECT_NE(cur_seq[2], 0);
 }
 
 #endif
@@ -1409,36 +1409,36 @@ TEST_P(TDMClient, ClientVblankWaitNullObject)
 {
        unsigned int cur_seq = 0;
 
-       ASSERT_EQ(tdm_client_vblank_wait(NULL, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_client_vblank_wait(NULL, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMClient, ClientVblankWaitNullOther)
 {
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
-       ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMClient, ClientVblankWaitDpmsOff)
 {
        tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
 
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
-       ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
+       EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
        while (dpms != TDM_OUTPUT_DPMS_OFF)
-               ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
-       ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF);
+               EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+       EXPECT_EQ(dpms, TDM_OUTPUT_DPMS_OFF);
 
-       ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_DPMS_OFF);
+       EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_DPMS_OFF);
 
-       ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
+       EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
        while (dpms != TDM_OUTPUT_DPMS_ON)
-               ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMClient, ClientVblankWaitSetEnableFakeDpmsOff)
@@ -1446,25 +1446,25 @@ TEST_P(TDMClient, ClientVblankWaitSetEnableFakeDpmsOff)
        tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
        bool done;
 
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
-       ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
+       EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
        while (dpms != TDM_OUTPUT_DPMS_OFF)
-               ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
 
-       ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
 
        done = false;
-       ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
 
        while (!done)
-               ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
 
-       ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
+       EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
        while (dpms != TDM_OUTPUT_DPMS_ON)
-               ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
 }
 
 /* tdm_client_vblank_wait */
@@ -1473,33 +1473,33 @@ TEST_P(TDMClient, ClientVblankIsWaiting)
        bool done;
        unsigned int waiting;
 
-       ASSERT_EQ(PrepareClient(), true);
-       ASSERT_EQ(PrepareOutput(), true);
-       ASSERT_EQ(PrepareVblank(), true);
+       EXPECT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareOutput(), true);
+       EXPECT_EQ(PrepareVblank(), true);
 
        done = false;
-       ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
 
        waiting = tdm_client_vblank_is_waiting(vblank);
-       ASSERT_EQ(waiting, 1);
+       EXPECT_EQ(waiting, 1);
 
        start = tdm_helper_get_time();
        while (!done)
-               ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
        end = tdm_helper_get_time();
 
        /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
-       ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
+       EXPECT_LT((end - start), (vrefresh_interval + vrefresh_interval));
 
        waiting = tdm_client_vblank_is_waiting(vblank);
-       ASSERT_EQ(waiting, 0);
+       EXPECT_EQ(waiting, 0);
 }
 
 /* tdm_client_vblank_wait */
 TEST_P(TDMClient, ClientVblankIsWaitingNullObject)
 {
        unsigned int waiting = tdm_client_vblank_is_waiting(NULL);
-       ASSERT_EQ(waiting, 0);
+       EXPECT_EQ(waiting, 0);
 }
 
 TEST_P(TDMClient, ClientCreateVOutput)
@@ -1510,15 +1510,15 @@ TEST_P(TDMClient, ClientCreateVOutput)
 
        virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
        if (virtual_conf == 0) {
-               ASSERT_EQ(virtual_conf, 0);
+               EXPECT_EQ(virtual_conf, 0);
                return;
        }
 
-       ASSERT_EQ(PrepareClient(), true);
+       EXPECT_EQ(PrepareClient(), true);
 
        voutput = tdm_client_create_voutput(client, name, &ret);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
-       ASSERT_NE(voutput, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_NE(voutput, NULL);
 
        tdm_client_voutput_destroy(voutput);
 }
@@ -1591,7 +1591,7 @@ void TDMVirtualOutput::ServerFork(void)
                return;
 
        server_pid = _tc_tdm_client_server_fork(pipe_parent, pipe_child);
-       ASSERT_GT(server_pid, 0);
+       EXPECT_GT(server_pid, 0);
 }
 
 void TDMVirtualOutput::SetUpTestCase(void)
@@ -1602,7 +1602,7 @@ void TDMVirtualOutput::SetUpTestCase(void)
        if (server_pid == -1)
                ServerFork();
 
-       ASSERT_EQ(PrepareVOutput(), true);
+       EXPECT_EQ(PrepareVOutput(), true);
 }
 
 void TDMVirtualOutput::TearDownTestCase(void)
@@ -1676,13 +1676,13 @@ TEST_F(TDMVirtualOutput, SetAvailableModes)
 
        if (this->voutput == NULL) {
                virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
-               ASSERT_EQ(virtual_conf, 0);
+               EXPECT_EQ(virtual_conf, 0);
                return;
        }
        _tc_tdm_client_virutual_make_available_mode(modes, count);
 
        ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 }
 
 TEST_F(TDMVirtualOutput, FailTestSetAvailableModes)
@@ -1694,15 +1694,15 @@ TEST_F(TDMVirtualOutput, FailTestSetAvailableModes)
 
        if (this->voutput == NULL) {
                virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
-               ASSERT_EQ(virtual_conf, 0);
+               EXPECT_EQ(virtual_conf, 0);
                return;
        }
 
        ret = tdm_client_voutput_set_available_modes(NULL, modes, count);
-       ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 
        ret = tdm_client_voutput_set_available_modes(this->voutput, NULL, count);
-       ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_F(TDMVirtualOutput, SetPhysicalSize)
@@ -1713,12 +1713,12 @@ TEST_F(TDMVirtualOutput, SetPhysicalSize)
 
        if (this->voutput == NULL) {
                virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
-               ASSERT_EQ(virtual_conf, 0);
+               EXPECT_EQ(virtual_conf, 0);
                return;
        }
 
        ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 }
 
 TEST_F(TDMVirtualOutput, FailTestSetPhysicalSize)
@@ -1729,12 +1729,12 @@ TEST_F(TDMVirtualOutput, FailTestSetPhysicalSize)
 
        if (this->voutput == NULL) {
                virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
-               ASSERT_EQ(virtual_conf, 0);
+               EXPECT_EQ(virtual_conf, 0);
                return;
        }
 
        ret = tdm_client_voutput_set_physical_size(this->voutput, invalid_mmWidth, invalid_mmHeight);
-       ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 }
 
 static void
@@ -1753,15 +1753,15 @@ TEST_F(TDMVirtualOutput, AddCommitHandler)
 
        if (this->voutput == NULL) {
                virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
-               ASSERT_EQ(virtual_conf, 0);
+               EXPECT_EQ(virtual_conf, 0);
                return;
        }
 
        ret = tdm_client_voutput_add_commit_handler(this->voutput,
                                                                                                _tc_tdm_client_voutput_commit_handler,
                                                                                                &flag_callback_called);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
-//     ASSERT_EQ(flag_callback_called, 1);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
+//     EXPECT_EQ(flag_callback_called, 1);
 
        tdm_client_voutput_remove_commit_handler(this->voutput,
                                                                                         _tc_tdm_client_voutput_commit_handler,
@@ -1775,12 +1775,12 @@ TEST_F(TDMVirtualOutput, CommitDone)
 
        if (this->voutput == NULL) {
                virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
-               ASSERT_EQ(virtual_conf, 0);
+               EXPECT_EQ(virtual_conf, 0);
                return;
        }
 
        ret = tdm_client_voutput_commit_done(this->voutput);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 }
 
 TEST_F(TDMVirtualOutput, GetClientOutput)
@@ -1791,13 +1791,13 @@ TEST_F(TDMVirtualOutput, GetClientOutput)
 
        if (this->voutput == NULL) {
                virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
-               ASSERT_EQ(virtual_conf, 0);
+               EXPECT_EQ(virtual_conf, 0);
                return;
        }
 
        output = tdm_client_voutput_get_client_output(this->voutput, &ret);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
-       ASSERT_NE(output, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_NE(output, NULL);
 }
 
 static void
@@ -1858,38 +1858,38 @@ TEST_F(TDMVirtualOutput, ConnectDisconnect)
 
        if (this->voutput == NULL) {
                virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
-               ASSERT_EQ(virtual_conf, 0);
+               EXPECT_EQ(virtual_conf, 0);
                return;
        }
 
        output = tdm_client_voutput_get_client_output(this->voutput, &ret);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
-       ASSERT_NE(output, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_NE(output, NULL);
 
        ret = tdm_client_output_add_change_handler(output, _tc_voutput_output_handler_cb, &done);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        ret = tdm_client_output_add_change_handler(output, _tc_voutput_output_handler_cb2, &done2);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        _tc_tdm_client_virutual_make_available_mode(modes, count);
        ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        ret = tdm_client_voutput_connect(this->voutput);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        while (!done)
-               ASSERT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
 
        ret = tdm_client_voutput_disconnect(this->voutput);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        while (!done2)
-               ASSERT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
 
        tdm_client_output_remove_change_handler(output, _tc_voutput_output_handler_cb, &done);
        tdm_client_output_remove_change_handler(output, _tc_voutput_output_handler_cb2, &done2);
@@ -1909,44 +1909,44 @@ TEST_F(TDMVirtualOutput, SetMode)
 
        if (this->voutput == NULL) {
                virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
-               ASSERT_EQ(virtual_conf, 0);
+               EXPECT_EQ(virtual_conf, 0);
                return;
        }
 
        output = tdm_client_voutput_get_client_output(this->voutput, &ret);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
-       ASSERT_NE(output, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_NE(output, NULL);
 
        ret = tdm_client_output_add_change_handler(output, _tc_voutput_output_handler_cb, &done);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
        ret = tdm_client_output_add_change_handler(output, _tc_voutput_output_handler_cb2, &done2);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
        ret = tdm_client_output_add_change_handler(output, _tc_voutput_output_handler_cb3, &done3);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        _tc_tdm_client_virutual_make_available_mode(modes, count);
        ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        ret = tdm_client_voutput_connect(this->voutput);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        while (!done)
-               ASSERT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
 
-       ASSERT_EQ(tdm_client_voutput_set_mode(this->voutput, count - 1), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_client_voutput_set_mode(this->voutput, count - 1), TDM_ERROR_NONE);
 
        while (!done3)
-               ASSERT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
 
        ret = tdm_client_voutput_disconnect(this->voutput);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        while (!done2)
-               ASSERT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
 
        tdm_client_output_remove_change_handler(output, _tc_voutput_output_handler_cb, &done);
        tdm_client_output_remove_change_handler(output, _tc_voutput_output_handler_cb2, &done2);
@@ -1963,26 +1963,26 @@ TEST_F(TDMVirtualOutput, SetModeNullObject)
 
        if (this->voutput == NULL) {
                virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
-               ASSERT_EQ(virtual_conf, 0);
+               EXPECT_EQ(virtual_conf, 0);
                return;
        }
 
        ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        _tc_tdm_client_virutual_make_available_mode(modes, count);
        ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        ret = tdm_client_voutput_connect(this->voutput);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        tdm_client_handle_events_timeout(this->client, 50);
 
-       ASSERT_EQ(tdm_client_voutput_set_mode(NULL, 0), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_client_voutput_set_mode(NULL, 0), TDM_ERROR_INVALID_PARAMETER);
 
        ret = tdm_client_voutput_disconnect(this->voutput);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        tdm_client_handle_events_timeout(this->client, 0);
 }
@@ -1997,26 +1997,26 @@ TEST_F(TDMVirtualOutput, SetModeInvalidIndex)
 
        if (this->voutput == NULL) {
                virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
-               ASSERT_EQ(virtual_conf, 0);
+               EXPECT_EQ(virtual_conf, 0);
                return;
        }
 
        ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        _tc_tdm_client_virutual_make_available_mode(modes, count);
        ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        ret = tdm_client_voutput_connect(this->voutput);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        tdm_client_handle_events_timeout(this->client, 50);
 
-       ASSERT_EQ(tdm_client_voutput_set_mode(this->voutput, -1), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_client_voutput_set_mode(this->voutput, -1), TDM_ERROR_INVALID_PARAMETER);
 
        ret = tdm_client_voutput_disconnect(this->voutput);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
 
        tdm_client_handle_events_timeout(this->client, 0);
 }