haltests: use EXPECT intead of ASSERT

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

diff --git a/haltests/src/tc_tdm_vblank.cpp b/haltests/src/tc_tdm_vblank.cpp
index 07e97ba..119dadc 100644 (file)
--- a/haltests/src/tc_tdm_vblank.cpp
+++ b/haltests/src/tc_tdm_vblank.cpp
@@ -184,8 +184,8 @@ TEST_P(TDMVblank, DISABLED_VblankSetClientVblankFps)
 
 TEST_P(TDMVblank, VblankSetClientVblankFpsNullObject)
 {
-       ASSERT_EQ(tdm_vblank_set_client_vblank_fps(0, NULL, 60), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(tdm_vblank_set_client_vblank_fps(123, NULL, 0), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_set_client_vblank_fps(0, NULL, 60), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_set_client_vblank_fps(123, NULL, 0), TDM_ERROR_INVALID_PARAMETER);
 }
 
 /* tdm_vblank_set_client_vblank_fps */
@@ -196,8 +196,8 @@ TEST_P(TDMVblank, DISABLED_VblankSetClientIgnoreGlobalFps)
 
 TEST_P(TDMVblank, VblankSetClientIgnoreGlobalFpsNullObject)
 {
-       ASSERT_EQ(tdm_vblank_set_client_ignore_global_fps(0, NULL, 0), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(tdm_vblank_set_client_ignore_global_fps(0, NULL, 1), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_set_client_ignore_global_fps(0, NULL, 0), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_set_client_ignore_global_fps(0, NULL, 1), TDM_ERROR_INVALID_PARAMETER);
 }
 
 /* tdm_vblank_create() */
@@ -208,8 +208,8 @@ TEST_P(TDMVblank, VblankCreateDestroy)
        for (int o = 0; o < output_count; o++) {
                tdm_error ret;
                tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
-               ASSERT_EQ(ret, TDM_ERROR_NONE);
-               ASSERT_NE(vblank, NULL);
+               EXPECT_EQ(ret, TDM_ERROR_NONE);
+               EXPECT_NE(vblank, NULL);
 
                tdm_vblank_destroy(vblank);
        }
@@ -222,8 +222,8 @@ TEST_P(TDMVblank, VblankCreateNullDpy)
        tdm_error ret;
 
        tdm_vblank *vblank = tdm_vblank_create(NULL, outputs[0], &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(TDMVblank, VblankCreateNullOutput)
@@ -231,8 +231,8 @@ TEST_P(TDMVblank, VblankCreateNullOutput)
        tdm_error ret;
 
        tdm_vblank *vblank = tdm_vblank_create(dpy, 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(TDMVblank, VblankCreateNullOther)
@@ -240,7 +240,7 @@ TEST_P(TDMVblank, VblankCreateNullOther)
        TDM_UT_SKIP_FLAG(has_outputs);
 
        tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[0], NULL);
-       ASSERT_NE(vblank, NULL);
+       EXPECT_NE(vblank, NULL);
 
        tdm_vblank_destroy(vblank);
 }
@@ -264,7 +264,7 @@ TEST_P(TDMVblank, VblankAddCreateHandler)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
 
        for (int o = 0; o < output_count; o++) {
                tdm_error ret;
@@ -272,9 +272,9 @@ TEST_P(TDMVblank, VblankAddCreateHandler)
                done = false;
 
                tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
-               ASSERT_EQ(ret, TDM_ERROR_NONE);
-               ASSERT_NE(vblank, NULL);
-               ASSERT_EQ(done, true);
+               EXPECT_EQ(ret, TDM_ERROR_NONE);
+               EXPECT_NE(vblank, NULL);
+               EXPECT_EQ(done, true);
 
                tdm_vblank_destroy(vblank);
        }
@@ -284,22 +284,22 @@ TEST_P(TDMVblank, VblankAddCreateHandlerTwice)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_NONE);
-       ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_BAD_REQUEST);
+       EXPECT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_BAD_REQUEST);
 }
 
 TEST_P(TDMVblank, VblankAddCreateHandlerNullObject)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(tdm_vblank_add_create_handler(NULL, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_add_create_handler(NULL, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMVblank, VblankAddCreateHandlerNullOther)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(tdm_vblank_add_create_handler(dpy, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_add_create_handler(dpy, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 /* tdm_vblank_remove_create_handler */
@@ -307,7 +307,7 @@ TEST_P(TDMVblank, VblankRemoveCreateHandler)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
        tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this);
 
        for (int o = 0; o < output_count; o++) {
@@ -316,9 +316,9 @@ TEST_P(TDMVblank, VblankRemoveCreateHandler)
                done = false;
 
                tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
-               ASSERT_EQ(ret, TDM_ERROR_NONE);
-               ASSERT_NE(vblank, NULL);
-               ASSERT_EQ(done, false);
+               EXPECT_EQ(ret, TDM_ERROR_NONE);
+               EXPECT_NE(vblank, NULL);
+               EXPECT_EQ(done, false);
 
                tdm_vblank_destroy(vblank);
        }
@@ -328,7 +328,7 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerFewTimes)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
 
        tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this);
        tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this);
@@ -340,9 +340,9 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerFewTimes)
                done = false;
 
                tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
-               ASSERT_EQ(ret, TDM_ERROR_NONE);
-               ASSERT_NE(vblank, NULL);
-               ASSERT_EQ(done, false);
+               EXPECT_EQ(ret, TDM_ERROR_NONE);
+               EXPECT_NE(vblank, NULL);
+               EXPECT_EQ(done, false);
 
                tdm_vblank_destroy(vblank);
        }
@@ -352,7 +352,7 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerDifferentData)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
 
        tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL);
 
@@ -362,9 +362,9 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerDifferentData)
                done = false;
 
                tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
-               ASSERT_EQ(ret, TDM_ERROR_NONE);
-               ASSERT_NE(vblank, NULL);
-               ASSERT_EQ(done, true);
+               EXPECT_EQ(ret, TDM_ERROR_NONE);
+               EXPECT_NE(vblank, NULL);
+               EXPECT_EQ(done, true);
 
                tdm_vblank_destroy(vblank);
        }
@@ -382,7 +382,7 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerInHandler)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb2, this), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb2, this), TDM_ERROR_NONE);
 
        for (int o = 0; o < output_count; o++) {
                tdm_error ret;
@@ -390,12 +390,12 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerInHandler)
                done = false;
 
                tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
-               ASSERT_EQ(ret, TDM_ERROR_NONE);
-               ASSERT_NE(vblank, NULL);
+               EXPECT_EQ(ret, TDM_ERROR_NONE);
+               EXPECT_NE(vblank, NULL);
                if (o == 0)
-                       ASSERT_EQ(done, true);
+                       EXPECT_EQ(done, true);
                else
-                       ASSERT_EQ(done, false);
+                       EXPECT_EQ(done, false);
 
                tdm_vblank_destroy(vblank);
        }
@@ -420,29 +420,29 @@ TEST_P(TDMVblank, VblankGetOutput)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                tdm_error ret;
-               ASSERT_NE(tdm_vblank_get_output(vblanks[v], &ret), NULL);
-               ASSERT_EQ(ret, TDM_ERROR_NONE);
+               EXPECT_NE(tdm_vblank_get_output(vblanks[v], &ret), NULL);
+               EXPECT_EQ(ret, TDM_ERROR_NONE);
        }
 }
 
 TEST_P(TDMVblank, VblankGetOutputNullObject)
 {
        tdm_error ret;
-       ASSERT_EQ(tdm_vblank_get_output(NULL, &ret), NULL);
-       ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_get_output(NULL, &ret), NULL);
+       EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMVblank, VblankGetOutputNullOther)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
-       ASSERT_NE(tdm_vblank_get_output(vblanks[0], NULL), NULL);
+       EXPECT_NE(tdm_vblank_get_output(vblanks[0], NULL), NULL);
 }
 
 /* tdm_vblank_get_client_pid() */
@@ -450,30 +450,30 @@ TEST_P(TDMVblank, VblankGetClientPid)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                pid_t pid = (pid_t)TDM_UT_INVALID_VALUE;
-               ASSERT_EQ(tdm_vblank_get_client_pid(vblanks[v], &pid), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_get_client_pid(vblanks[v], &pid), TDM_ERROR_NONE);
                /* client pid should be 0 in case vblank is created in server side */
-               ASSERT_EQ(pid, 0);
+               EXPECT_EQ(pid, 0);
        }
 }
 
 TEST_P(TDMVblank, VblankGetClientPidNullObject)
 {
        pid_t pid = (pid_t)TDM_UT_INVALID_VALUE;
-       ASSERT_EQ(tdm_vblank_get_client_pid(NULL, &pid), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(pid, (pid_t)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_vblank_get_client_pid(NULL, &pid), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(pid, (pid_t)TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMVblank, VblankGetClientPidNullOther)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
-       ASSERT_EQ(tdm_vblank_get_client_pid(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_get_client_pid(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 /* tdm_vblank_set_name() */
@@ -481,25 +481,25 @@ TEST_P(TDMVblank, VblankSetName)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++)
-               ASSERT_EQ(tdm_vblank_set_name(vblanks[v], TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_name(vblanks[v], TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMVblank, VblankSetNameNullObject)
 {
-       ASSERT_EQ(tdm_vblank_set_name(NULL, TDM_UT_VBLANK_NAME), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_set_name(NULL, TDM_UT_VBLANK_NAME), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMVblank, VblankSetNameNullOther)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++)
-               ASSERT_EQ(tdm_vblank_set_name(vblanks[v], NULL), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_name(vblanks[v], NULL), TDM_ERROR_NONE);
 }
 
 /* tdm_vblank_get_name() */
@@ -507,42 +507,42 @@ TEST_P(TDMVblank, VblankGetName)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                const char *name = (const char *)TDM_UT_INVALID_VALUE;
-               ASSERT_EQ(tdm_vblank_set_name(vblanks[v], TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
-               ASSERT_EQ(tdm_vblank_get_name(vblanks[v], &name), TDM_ERROR_NONE);
-               ASSERT_STREQ(name, TDM_UT_VBLANK_NAME);
+               EXPECT_EQ(tdm_vblank_set_name(vblanks[v], TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_get_name(vblanks[v], &name), TDM_ERROR_NONE);
+               EXPECT_STREQ(name, TDM_UT_VBLANK_NAME);
        }
 }
 
 TEST_P(TDMVblank, VblankGetNameNullObject)
 {
        const char *name = (const char *)TDM_UT_INVALID_VALUE;
-       ASSERT_EQ(tdm_vblank_get_name(NULL, &name), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(name, (const char *)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_vblank_get_name(NULL, &name), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(name, (const char *)TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMVblank, VblankGetNameNullOther)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
-       ASSERT_EQ(tdm_vblank_get_name(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_get_name(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMVblank, VblankGetNameNoSet)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                const char *name = (const char *)TDM_UT_INVALID_VALUE;
-               ASSERT_EQ(tdm_vblank_get_name(vblanks[v], &name), TDM_ERROR_NONE);
-               ASSERT_STREQ(name, TDM_VBLANK_DEFAULT_NAME);
+               EXPECT_EQ(tdm_vblank_get_name(vblanks[v], &name), TDM_ERROR_NONE);
+               EXPECT_STREQ(name, TDM_VBLANK_DEFAULT_NAME);
        }
 }
 
@@ -551,26 +551,26 @@ TEST_P(TDMVblank, VblankSetFps)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++)
-               ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMVblank, VblankSetFpsNullObject)
 {
-       ASSERT_EQ(tdm_vblank_set_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_set_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMVblank, VblankSetFpsTwice)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
-               ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
-               ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
        }
 }
 
@@ -579,26 +579,26 @@ TEST_P(TDMVblank, VblankSetFixedFps)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++)
-               ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMVblank, VblankSetFixedFpsNullObject)
 {
-       ASSERT_EQ(tdm_vblank_set_fixed_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_set_fixed_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMVblank, VblankSetFixedFpsTwice)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
-               ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE);
-               ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE);
        }
 }
 
@@ -607,38 +607,38 @@ TEST_P(TDMVblank, VblankGetFps)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
-               ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
-               ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
-               ASSERT_EQ(fps, 60);
+               EXPECT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
+               EXPECT_EQ(fps, 60);
        }
 }
 
 TEST_P(TDMVblank, VblankGetFpsNullObject)
 {
        unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
-       ASSERT_EQ(tdm_vblank_get_fps(NULL, &fps), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(fps, (unsigned int)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_vblank_get_fps(NULL, &fps), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(fps, (unsigned int)TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMVblank, VblankGetFpsNullOther)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
-       ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_get_fps(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMVblank, VblankGetFpsNoSet)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestPrepareOutput(), true);
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestPrepareOutput(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
@@ -648,17 +648,17 @@ TEST_P(TDMVblank, VblankGetFpsNoSet)
                if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
                        continue;
 
-               ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
-               ASSERT_TRUE(fps != 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
+               EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
+               EXPECT_TRUE(fps != 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
 
                tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
-               ASSERT_NE(output, NULL);
-               ASSERT_EQ(ret, TDM_ERROR_NONE);
+               EXPECT_NE(output, NULL);
+               EXPECT_EQ(ret, TDM_ERROR_NONE);
 
-               ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
-               ASSERT_TRUE(mode != NULL && mode != (const tdm_output_mode *)TDM_UT_INVALID_VALUE);
+               EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
+               EXPECT_TRUE(mode != NULL && mode != (const tdm_output_mode *)TDM_UT_INVALID_VALUE);
 
-               ASSERT_EQ(fps, mode->vrefresh);
+               EXPECT_EQ(fps, mode->vrefresh);
        }
 }
 
@@ -666,54 +666,54 @@ TEST_P(TDMVblank, VblankGetFpsAfterSetFixedFps)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
 
-               ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
-               ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
-               ASSERT_EQ(fps, 60);
+               EXPECT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
+               EXPECT_EQ(fps, 60);
 
-               ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10), TDM_ERROR_NONE);
-               ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
-               ASSERT_EQ(fps, 10);
+               EXPECT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
+               EXPECT_EQ(fps, 10);
 
                /* should return TDM_ERROR_NONE because tdm_vblank_set_fixed_fps would be
                 * called by other who call tdm_vblank_set_fps. If returns error, other
                 * can't handle error.
                 */
-               ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
-               ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
-               ASSERT_EQ(fps, 10);
+               EXPECT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
+               EXPECT_EQ(fps, 10);
        }
 }
 
 /* tdm_vblank_ignore_global_fps() */
 TEST_P(TDMVblank, VblankIgnoreGlobalFpsNullObject)
 {
-       ASSERT_EQ(tdm_vblank_ignore_global_fps(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_ignore_global_fps(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMVblank, VblankIgnoreGlobalFpsSet)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++)
-               ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMVblank, VblankIgnoreGlobalFpsSetTwice)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
-               ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE);
-               ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE);
        }
 }
 
@@ -721,21 +721,21 @@ TEST_P(TDMVblank, VblankIgnoreGlobalFpsUnset)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++)
-               ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMVblank, VblankIgnoreGlobalFpsUnsetTwice)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
-               ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE);
-               ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE);
        }
 }
 
@@ -744,26 +744,26 @@ TEST_P(TDMVblank, VblankSetOffset)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++)
-               ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMVblank, VblankSetOffsetNullObject)
 {
-       ASSERT_EQ(tdm_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMVblank, VblankSetOffsetTwice)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
-               ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
-               ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
        }
 }
 
@@ -772,42 +772,42 @@ TEST_P(TDMVblank, VblankGetOffset)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                int offset = TDM_UT_INVALID_VALUE;
-               ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
-               ASSERT_EQ(tdm_vblank_get_offset(vblanks[v], &offset), TDM_ERROR_NONE);
-               ASSERT_EQ(offset, 10);
+               EXPECT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_get_offset(vblanks[v], &offset), TDM_ERROR_NONE);
+               EXPECT_EQ(offset, 10);
        }
 }
 
 TEST_P(TDMVblank, VblankGetOffsetNullObject)
 {
        int offset = TDM_UT_INVALID_VALUE;
-       ASSERT_EQ(tdm_vblank_get_offset(NULL, &offset), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(offset, TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_vblank_get_offset(NULL, &offset), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(offset, TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMVblank, VblankGetOffsetNullOther)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
-       ASSERT_EQ(tdm_vblank_get_offset(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_get_offset(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMVblank, VblankGetOffsetNoSet)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                int offset = TDM_UT_INVALID_VALUE;
-               ASSERT_EQ(tdm_vblank_get_offset(vblanks[v], &offset), TDM_ERROR_NONE);
-               ASSERT_EQ(offset, 0);
+               EXPECT_EQ(tdm_vblank_get_offset(vblanks[v], &offset), TDM_ERROR_NONE);
+               EXPECT_EQ(offset, 0);
        }
 }
 
@@ -816,26 +816,26 @@ TEST_P(TDMVblank, VblankSetEnableFake)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++)
-               ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMVblank, VblankSetEnableFakeNullObject)
 {
-       ASSERT_EQ(tdm_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMVblank, VblankSetEnableFakeTwice)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
-               ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
-               ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
        }
 }
 
@@ -844,46 +844,46 @@ TEST_P(TDMVblank, VblankGetEnableFake)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                unsigned int enable_fake;
-               ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
-               ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE);
-               ASSERT_EQ(enable_fake, 1);
+               EXPECT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE);
+               EXPECT_EQ(enable_fake, 1);
 
-               ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 0), TDM_ERROR_NONE);
-               ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE);
-               ASSERT_EQ(enable_fake, 0);
+               EXPECT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 0), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE);
+               EXPECT_EQ(enable_fake, 0);
        }
 }
 
 TEST_P(TDMVblank, VblankGetEnableFakeNullObject)
 {
        unsigned int enable_fake = (unsigned int)TDM_UT_INVALID_VALUE;
-       ASSERT_EQ(tdm_vblank_get_enable_fake(NULL, &enable_fake), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(enable_fake, (unsigned int)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_vblank_get_enable_fake(NULL, &enable_fake), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(enable_fake, (unsigned int)TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMVblank, VblankGetEnableFakeNullOther)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
-       ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_get_enable_fake(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMVblank, VblankGetEnableFakeNoSet)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                unsigned int enable_fake;
-               ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE);
-               ASSERT_EQ(enable_fake, 0);
+               EXPECT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE);
+               EXPECT_EQ(enable_fake, 0);
        }
 }
 
@@ -900,8 +900,8 @@ TEST_P(TDMVblank, VblankWait)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestPrepareOutput(), true);
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestPrepareOutput(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
@@ -910,21 +910,21 @@ TEST_P(TDMVblank, VblankWait)
                if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
                        continue;
 
-               ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
-               ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
+               EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
+               EXPECT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
                interval = 1.0 / (double)fps;
 
                for (int t = 0; t < 10; t++) {
                        unsigned int cur_seq = 0;
 
                        start = tdm_helper_get_time();
-                       ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
+                       EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
                        while (cur_seq == 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();
 
                        /* "+ interval" consider the delay of socket communication between kernel and platform */
-                       ASSERT_LT((end - start), (interval + interval));
+                       EXPECT_LT((end - start), (interval + interval));
                }
        }
 }
@@ -933,8 +933,8 @@ TEST_P(TDMVblank, VblankWaitFewTime)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestPrepareOutput(), true);
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestPrepareOutput(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
@@ -943,8 +943,8 @@ TEST_P(TDMVblank, VblankWaitFewTime)
                if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
                        continue;
 
-               ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
-               ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
+               EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
+               EXPECT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
                interval = 1.0 / (double)fps;
 
                for (int t = 0; t < 10; t++) {
@@ -952,18 +952,18 @@ TEST_P(TDMVblank, VblankWaitFewTime)
 
                        cur_seq = seq1 = seq2 = 0;
                        start = tdm_helper_get_time();
-                       ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
-                       ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &seq1), TDM_ERROR_NONE);
-                       ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &seq2), TDM_ERROR_NONE);
+                       EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
+                       EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &seq1), TDM_ERROR_NONE);
+                       EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &seq2), TDM_ERROR_NONE);
                        while (cur_seq == 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(seq1, 0);
-                       ASSERT_NE(seq2, 0);
+                       EXPECT_NE(seq1, 0);
+                       EXPECT_NE(seq2, 0);
 
                        /* "+ interval" consider the delay of socket communication between kernel and platform */
-                       ASSERT_LT((end - start), (interval + interval));
+                       EXPECT_LT((end - start), (interval + interval));
                }
        }
 }
@@ -972,18 +972,18 @@ TEST_P(TDMVblank, VblankWaitInterval0)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestPrepareOutput(), true);
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestPrepareOutput(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
-       ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, _tc_tdm_vblank_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, _tc_tdm_vblank_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMVblank, VblankWaitInterval)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestPrepareOutput(), true);
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestPrepareOutput(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
@@ -992,8 +992,8 @@ TEST_P(TDMVblank, VblankWaitInterval)
                if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
                        continue;
 
-               ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
-               ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
+               EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
+               EXPECT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
                interval = 1.0 / (double)fps;
 
                /* start from 1 */
@@ -1001,14 +1001,14 @@ TEST_P(TDMVblank, VblankWaitInterval)
                        unsigned int cur_seq = 0;
 
                        start = tdm_helper_get_time();
-                       ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, t, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
+                       EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, t, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
                        while (cur_seq == 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();
 
                        /* "+ interval" consider the delay of socket communication between kernel and platform */
-                       ASSERT_GT((end - start), interval * (t - 1));
-                       ASSERT_LT((end - start), interval * t + interval);
+                       EXPECT_GT((end - start), interval * (t - 1));
+                       EXPECT_LT((end - start), interval * t + interval);
                }
        }
 }
@@ -1017,8 +1017,8 @@ TEST_P(TDMVblank, VblankWaitSeq)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestPrepareOutput(), true);
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestPrepareOutput(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
@@ -1027,25 +1027,25 @@ TEST_P(TDMVblank, VblankWaitSeq)
                if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
                        continue;
 
-               ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
-               ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
+               EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
+               EXPECT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
                interval = 1.0 / (double)fps;
 
                for (int t = 0; t < 10; t++) {
                        unsigned int cur_seq = 0, temp = 0;
 
-                       ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
+                       EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
                        while (cur_seq == 0)
-                               ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+                               EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
 
                        start = tdm_helper_get_time();
-                       ASSERT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + 1, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
+                       EXPECT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + 1, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
                        while (temp == 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();
 
                        /* "+ interval" consider the delay of socket communication between kernel and platform */
-                       ASSERT_LT((end - start), (interval + interval));
+                       EXPECT_LT((end - start), (interval + interval));
                }
        }
 }
@@ -1054,8 +1054,8 @@ TEST_P(TDMVblank, VblankWaitSeqInterval)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestPrepareOutput(), true);
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestPrepareOutput(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
@@ -1064,27 +1064,27 @@ TEST_P(TDMVblank, VblankWaitSeqInterval)
                if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
                        continue;
 
-               ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
-               ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
+               EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
+               EXPECT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
                interval = 1.0 / (double)fps;
 
                /* start from 1 */
                for (int t = 1; t < 10; t++) {
                        unsigned int cur_seq = 0, temp = 0;
 
-                       ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
+                       EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
                        while (cur_seq == 0)
-                               ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+                               EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
 
                        start = tdm_helper_get_time();
-                       ASSERT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + t, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
+                       EXPECT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + t, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
                        while (temp == 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();
 
                        /* "+ interval" consider the delay of socket communication between kernel and platform */
-                       ASSERT_GT((end - start), (interval * (t - 1)));
-                       ASSERT_LT((end - start), (interval * t + interval));
+                       EXPECT_GT((end - start), (interval * (t - 1)));
+                       EXPECT_LT((end - start), (interval * t + interval));
                }
        }
 }
@@ -1095,36 +1095,36 @@ TEST_P(TDMVblank, VblankWaitNullObject)
 
        unsigned int cur_seq = 0;
 
-       ASSERT_EQ(tdm_vblank_wait(NULL, 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_wait(NULL, 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMVblank, VblankWaitNullOther)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
-       ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMVblank, VblankWaitDpmsOff)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestPrepareOutput(), true);
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestPrepareOutput(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                tdm_error ret;
                tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
-               ASSERT_EQ(ret, TDM_ERROR_NONE);
+               EXPECT_EQ(ret, TDM_ERROR_NONE);
 
                if (!tc_tdm_output_is_connected(output))
                        continue;
 
-               ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
 
-               ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_DPMS_OFF);
+               EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_DPMS_OFF);
        }
 }
 
@@ -1132,24 +1132,24 @@ TEST_P(TDMVblank, VblankWaitBeforeDpmsOff)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestPrepareOutput(), true);
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestPrepareOutput(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                unsigned int temp = 0;
                tdm_error ret;
                tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
-               ASSERT_EQ(ret, TDM_ERROR_NONE);
+               EXPECT_EQ(ret, TDM_ERROR_NONE);
 
                if (!tc_tdm_output_is_connected(output))
                        continue;
 
-               ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
 
-               ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
 
                while (temp == 0)
-                       ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+                       EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
        }
 }
 
@@ -1157,13 +1157,13 @@ TEST_P(TDMVblank, VblankWaitSetEnableFakeDpmsOff)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestPrepareOutput(), true);
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestPrepareOutput(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                tdm_error ret;
                tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
-               ASSERT_EQ(ret, TDM_ERROR_NONE);
+               EXPECT_EQ(ret, TDM_ERROR_NONE);
 
                if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
                        continue;
@@ -1171,11 +1171,11 @@ TEST_P(TDMVblank, VblankWaitSetEnableFakeDpmsOff)
                if (!tc_tdm_output_is_connected(output))
                        continue;
 
-               ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
 
-               ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
 
-               ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_NONE);
        }
 }
 
@@ -1183,18 +1183,18 @@ TEST_P(TDMVblank, VblankWaitDisconnectedOutput)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestPrepareOutput(), true);
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestPrepareOutput(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                tdm_error ret;
                tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
-               ASSERT_EQ(ret, TDM_ERROR_NONE);
+               EXPECT_EQ(ret, TDM_ERROR_NONE);
 
                if (tc_tdm_output_is_connected(output))
                        continue;
 
-               ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_OUTPUT_DISCONNECTED);
+               EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_OUTPUT_DISCONNECTED);
        }
 }
 
@@ -1202,8 +1202,8 @@ TEST_P(TDMVblank, VblankWaitSetOffset)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestPrepareOutput(), true);
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestPrepareOutput(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
@@ -1212,24 +1212,24 @@ TEST_P(TDMVblank, VblankWaitSetOffset)
                if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
                        continue;
 
-               ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 100), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_offset(vblanks[v], 100), TDM_ERROR_NONE);
 
-               ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
-               ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
+               EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
+               EXPECT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
                interval = 1.0 / (double)fps;
 
                for (int t = 0; t < 3; t++) {
                        unsigned int cur_seq = 0;
 
                        start = tdm_helper_get_time();
-                       ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
+                       EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
                        while (cur_seq == 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();
 
                        /* "+ interval" consider the delay of socket communication between kernel and platform */
-                       ASSERT_GT((end - start), (0.1));
-                       ASSERT_LT((end - start), (interval + interval + 0.1));
+                       EXPECT_GT((end - start), (0.1));
+                       EXPECT_LT((end - start), (interval + interval + 0.1));
                }
        }
 }
@@ -1238,8 +1238,8 @@ TEST_P(TDMVblank, VblankWaitSetFps)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestPrepareOutput(), true);
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestPrepareOutput(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
@@ -1248,26 +1248,26 @@ TEST_P(TDMVblank, VblankWaitSetFps)
                if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
                        continue;
 
-               ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
-               ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
+               EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
+               EXPECT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
                vrefresh_interval = 1.0 / (double)fps;
 
                fps /= 2;
-               ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], fps), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_fps(vblanks[v], fps), TDM_ERROR_NONE);
                interval = 1.0 / (double)fps;
 
                for (int t = 0; t < 3; t++) {
                        unsigned int cur_seq = 0;
 
                        start = tdm_helper_get_time();
-                       ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
+                       EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
                        while (cur_seq == 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();
 
                        /* "+ 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));
                }
        }
 }
@@ -1276,8 +1276,8 @@ TEST_P(TDMVblank, VblankWaitSetFixedFps)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestPrepareOutput(), true);
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestPrepareOutput(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
@@ -1286,27 +1286,27 @@ TEST_P(TDMVblank, VblankWaitSetFixedFps)
                if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
                        continue;
 
-               ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
-               ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
+               EXPECT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
+               EXPECT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
                interval = 1.0 / (double)fps;
 
-               ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], fps), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], fps), TDM_ERROR_NONE);
 
                /* this fps will be ignored because it has fixed fps value */
                fps /= 2;
-               ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], fps), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_set_fps(vblanks[v], fps), TDM_ERROR_NONE);
 
                for (int t = 0; t < 3; t++) {
                        unsigned int cur_seq = 0;
 
                        start = tdm_helper_get_time();
-                       ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
+                       EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
                        while (cur_seq == 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();
 
                        /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
-                       ASSERT_LT((end - start), (interval + interval));
+                       EXPECT_LT((end - start), (interval + interval));
                }
        }
 }
@@ -1321,19 +1321,19 @@ 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);
 
        if (!tc_tdm_vblank_is_avaiable(vblanks[0]))
                return;
 
-       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);
                interval = 1.0 / (double)(10 * (v + 1));
        }
 
@@ -1342,57 +1342,57 @@ 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[2] == 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();
 
        /* "+- 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));
 
-       ASSERT_EQ(cur_seq[1], 0);
-       ASSERT_EQ(cur_seq[0], 0);
+       EXPECT_EQ(cur_seq[1], 0);
+       EXPECT_EQ(cur_seq[0], 0);
 
        while (cur_seq[1] == 0)
-               ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
-       ASSERT_EQ(cur_seq[0], 0);
+               EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+       EXPECT_EQ(cur_seq[0], 0);
 
        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);
 
        /* disable test. global fps doesn't effect server's vblanks */
        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[2] == 0)
-               ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
-       ASSERT_EQ(cur_seq[1], 0);
-       ASSERT_EQ(cur_seq[0], 0);
+               EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+       EXPECT_EQ(cur_seq[1], 0);
+       EXPECT_EQ(cur_seq[0], 0);
 
        while (cur_seq[1] == 0)
-               ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
-       ASSERT_EQ(cur_seq[0], 0);
+               EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+       EXPECT_EQ(cur_seq[0], 0);
 }
 
 TEST_P(TDMVblank, VblankWaitSetEnableFakeDisconnected)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestPrepareOutput(), true);
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestPrepareOutput(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        for (int v = 0; v < vblank_count; v++) {
                tdm_error ret;
                tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
-               ASSERT_EQ(ret, TDM_ERROR_NONE);
+               EXPECT_EQ(ret, TDM_ERROR_NONE);
 
                if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
                        continue;
@@ -1400,9 +1400,9 @@ TEST_P(TDMVblank, VblankWaitSetEnableFakeDisconnected)
                if (tc_tdm_output_is_connected(output))
                        continue;
 
-               ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_DPMS_OFF);
+               EXPECT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_DPMS_OFF);
 
-               ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_NONE);
        }
 }
 
@@ -1415,17 +1415,17 @@ TEST_P(TDMVblank, VblankWaitTimeout)
 {
        TDM_UT_SKIP_FLAG(has_outputs);
 
-       ASSERT_EQ(TestPrepareOutput(), true);
-       ASSERT_EQ(TestCreateVblanks(), true);
+       EXPECT_EQ(TestPrepareOutput(), true);
+       EXPECT_EQ(TestCreateVblanks(), true);
 
        if (vblank_count > 0) {
                tdm_vblank *vblank = vblanks[0];
                unsigned int cur_seq = 0;
 
-               ASSERT_EQ(tdm_vblank_wait(vblank, 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_vblank_wait(vblank, 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
                usleep(1200000);
                while (cur_seq == 0)
-                       ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+                       EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
        }
 }