haltests: use EXPECT intead of ASSERT

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

diff --git a/haltests/src/tc_tdm_display.cpp b/haltests/src/tc_tdm_display.cpp
index 9ec8ff3..80e49d8 100644 (file)
--- a/haltests/src/tc_tdm_display.cpp
+++ b/haltests/src/tc_tdm_display.cpp
@@ -49,16 +49,16 @@ void TDMDisplay::SetUp(void)
        TDMEnv::SetUp();
 
        dpy = tdm_display_init(&ret);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
-       ASSERT_NE(dpy, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_NE(dpy, NULL);
 
        bufmgr = tbm_bufmgr_init(-1);
-       ASSERT_NE(bufmgr, NULL);
+       EXPECT_NE(bufmgr, NULL);
 
-       ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
-       ASSERT_GT(count, 0);
+       EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
+       EXPECT_GT(count, 0);
 
-       ASSERT_EQ(tdm_display_get_capabilities(dpy, &capabilities), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_display_get_capabilities(dpy, &capabilities), TDM_ERROR_NONE);
        has_pp_cap = capabilities & TDM_DISPLAY_CAPABILITY_PP;
        has_capture_cap = capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE;
 }
@@ -68,7 +68,7 @@ void TDMDisplay::TearDown(void)
        tbm_bufmgr_deinit(bufmgr);
        tdm_display_deinit(dpy);
 
-       ASSERT_EQ(tbm_bufmgr_debug_get_ref_count(), 0);
+       EXPECT_EQ(tbm_bufmgr_debug_get_ref_count(), 0);
 
        TDMEnv::TearDown();
 }
@@ -118,38 +118,38 @@ tc_tdm_display_has_capture_capability(tdm_display *dpy)
 
 TEST_P(TDMDisplay, DisplayUpdate)
 {
-       ASSERT_EQ(tdm_display_update(dpy), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_display_update(dpy), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMDisplay, DisplayUpdateNullObject)
 {
-       ASSERT_EQ(tdm_display_update(NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_display_update(NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMDisplay, DisplayGetFDSuccesful)
 {
        int fd = TDM_UT_INVALID_VALUE;
-       ASSERT_EQ(tdm_display_get_fd(dpy, &fd), TDM_ERROR_NONE);
-       ASSERT_NE(fd, TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_display_get_fd(dpy, &fd), TDM_ERROR_NONE);
+       EXPECT_NE(fd, TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMDisplay, DisplayGetFDNullObject)
 {
        int fd = TDM_UT_INVALID_VALUE;
-       ASSERT_EQ(tdm_display_get_fd(NULL, &fd), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(fd, TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_display_get_fd(NULL, &fd), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(fd, TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMDisplay, DisplayGetFDNullFD)
 {
-       ASSERT_EQ(tdm_display_get_fd(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_display_get_fd(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 /* DISABLED */
 TEST_P(TDMDisplay, DISABLED_DisplayHandleEvents)
 {
        /* TODO Generate events*/
-       ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+       EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMDisplay, DisplayFlush)
@@ -168,11 +168,11 @@ TEST_P(TDMDisplay, DisplayGetBackendInfo)
        const char *vendor = (const char*)TDM_UT_INVALID_VALUE;
        int major = TDM_UT_INVALID_VALUE, minor = TDM_UT_INVALID_VALUE;
 
-       ASSERT_EQ(tdm_display_get_backend_info(dpy, &name, &vendor, &major, &minor), TDM_ERROR_NONE);
-       ASSERT_NE(name, (const char*)TDM_UT_INVALID_VALUE);
-       ASSERT_NE(vendor, (const char*)TDM_UT_INVALID_VALUE);
-       ASSERT_NE(major, TDM_UT_INVALID_VALUE);
-       ASSERT_NE(minor, TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_display_get_backend_info(dpy, &name, &vendor, &major, &minor), TDM_ERROR_NONE);
+       EXPECT_NE(name, (const char*)TDM_UT_INVALID_VALUE);
+       EXPECT_NE(vendor, (const char*)TDM_UT_INVALID_VALUE);
+       EXPECT_NE(major, TDM_UT_INVALID_VALUE);
+       EXPECT_NE(minor, TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMDisplay, DisplayGetBackendInfoNullObject)
@@ -181,35 +181,35 @@ TEST_P(TDMDisplay, DisplayGetBackendInfoNullObject)
        const char *vendor = (const char*)TDM_UT_INVALID_VALUE;
        int major = TDM_UT_INVALID_VALUE, minor = TDM_UT_INVALID_VALUE;
 
-       ASSERT_EQ(tdm_display_get_backend_info(NULL, &name, &vendor, &major, &minor), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(name, (const char*)TDM_UT_INVALID_VALUE);
-       ASSERT_EQ(vendor, (const char*)TDM_UT_INVALID_VALUE);
-       ASSERT_EQ(major, TDM_UT_INVALID_VALUE);
-       ASSERT_EQ(minor, TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_display_get_backend_info(NULL, &name, &vendor, &major, &minor), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(name, (const char*)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(vendor, (const char*)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(major, TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(minor, TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMDisplay, DisplayGetBackendInfoNullOther)
 {
-       ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
+       EXPECT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
 }
 
 TEST_P(TDMDisplay, DisplayGetCapabilities)
 {
        tdm_display_capability capabilities = (tdm_display_capability)TDM_UT_INVALID_VALUE;
-       ASSERT_EQ(tdm_display_get_capabilities(dpy, &capabilities), TDM_ERROR_NONE);
-       ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_display_get_capabilities(dpy, &capabilities), TDM_ERROR_NONE);
+       EXPECT_NE(capabilities, TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMDisplay, DisplayGetCapabilitiesNullObject)
 {
        tdm_display_capability capabilities = (tdm_display_capability)TDM_UT_INVALID_VALUE;
-       ASSERT_EQ(tdm_display_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(capabilities, (tdm_display_capability)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_display_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(capabilities, (tdm_display_capability)TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMDisplay, DisplayGetCapabilitiesNullOther)
 {
-       ASSERT_EQ(tdm_display_get_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_display_get_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMDisplay, DisplayGetPPCapabilities)
@@ -219,22 +219,22 @@ TEST_P(TDMDisplay, DisplayGetPPCapabilities)
        if (!has_pp_cap)
                return;
        ret = tdm_display_get_pp_capabilities(dpy, &capabilities);
-       ASSERT_TRUE(ret == TDM_ERROR_NONE || ret == TDM_ERROR_NO_CAPABILITY);
+       EXPECT_TRUE(ret == TDM_ERROR_NONE || ret == TDM_ERROR_NO_CAPABILITY);
 
        if (ret == TDM_ERROR_NONE)
-               ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE);
+               EXPECT_NE(capabilities, TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMDisplay, DisplayGetPPCapabilitiesNullObject)
 {
        tdm_pp_capability capabilities = (tdm_pp_capability)TDM_UT_INVALID_VALUE;
-       ASSERT_EQ(tdm_display_get_pp_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(capabilities, (tdm_pp_capability)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_display_get_pp_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(capabilities, (tdm_pp_capability)TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMDisplay, DisplayGetPPCapabilitiesNullOther)
 {
-       ASSERT_EQ(tdm_display_get_pp_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_display_get_pp_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMDisplay, DisplayGetCaptureCapabilities)
@@ -246,60 +246,60 @@ TEST_P(TDMDisplay, DisplayGetCaptureCapabilities)
                return;
 
        ret = tdm_display_get_capture_capabilities(dpy, &capabilities);
-       ASSERT_TRUE(ret == TDM_ERROR_NONE || ret == TDM_ERROR_NO_CAPABILITY);
+       EXPECT_TRUE(ret == TDM_ERROR_NONE || ret == TDM_ERROR_NO_CAPABILITY);
 
        if (ret == TDM_ERROR_NONE)
-               ASSERT_NE(capabilities, (tdm_capture_capability)TDM_UT_INVALID_VALUE);
+               EXPECT_NE(capabilities, (tdm_capture_capability)TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMDisplay, DisplayGetCaptureCapabilitiesNullObject)
 {
        tdm_capture_capability capabilities = (tdm_capture_capability)TDM_UT_INVALID_VALUE;
-       ASSERT_EQ(tdm_display_get_capture_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(capabilities, (tdm_capture_capability)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_display_get_capture_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(capabilities, (tdm_capture_capability)TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMDisplay, DisplayGetCaptureCapabilitiesNullOther)
 {
-       ASSERT_EQ(tdm_display_get_capture_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_display_get_capture_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMDisplay, DisplayGetMaxLayerCount)
 {
        int max_count = TDM_UT_INVALID_VALUE;
-       ASSERT_EQ(tdm_display_get_max_layer_count(dpy, &max_count), TDM_ERROR_NONE);
-       ASSERT_NE(max_count, TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_display_get_max_layer_count(dpy, &max_count), TDM_ERROR_NONE);
+       EXPECT_NE(max_count, TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMDisplay, DisplayGetMaxLayerCountNullObject)
 {
        int max_count = TDM_UT_INVALID_VALUE;
-       ASSERT_EQ(tdm_display_get_max_layer_count(NULL, &max_count), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(max_count, TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_display_get_max_layer_count(NULL, &max_count), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(max_count, TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMDisplay, DisplayGetMaxLayerCountNullOther)
 {
-       ASSERT_EQ(tdm_display_get_max_layer_count(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_display_get_max_layer_count(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMDisplay, DisplayGetOutputCount)
 {
        int count = TDM_UT_INVALID_VALUE;
-       ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
-       ASSERT_NE(count, TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
+       EXPECT_NE(count, TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMDisplay, DisplayGetOutputCountNullObject)
 {
        int count = TDM_UT_INVALID_VALUE;
-       ASSERT_EQ(tdm_display_get_output_count(NULL, &count), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_display_get_output_count(NULL, &count), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMDisplay, DisplayGetOutputCountNullOther)
 {
-       ASSERT_EQ(tdm_display_get_output_count(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(tdm_display_get_output_count(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 }
 
 TEST_P(TDMDisplay, DisplayGetOutput)
@@ -308,13 +308,13 @@ TEST_P(TDMDisplay, DisplayGetOutput)
        int o, count = TDM_UT_INVALID_VALUE;
        tdm_error ret;
 
-       ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
-       ASSERT_GT(count, 0);
+       EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
+       EXPECT_GT(count, 0);
 
        for (o = 0; o < count; o++) {
                output = tdm_display_get_output(dpy, o, &ret);
-               ASSERT_EQ(ret, TDM_ERROR_NONE);
-               ASSERT_NE(output, NULL);
+               EXPECT_EQ(ret, TDM_ERROR_NONE);
+               EXPECT_NE(output, NULL);
        }
 }
 
@@ -323,12 +323,12 @@ TEST_P(TDMDisplay, DisplayGetOutputNullAll)
        tdm_output *output;
        int o, count = TDM_UT_INVALID_VALUE;
 
-       ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
-       ASSERT_GT(count, 0);
+       EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
+       EXPECT_GT(count, 0);
 
        for (o = 0; o < count; o++) {
                output = tdm_display_get_output(NULL, o, NULL);
-               ASSERT_EQ(output, NULL);
+               EXPECT_EQ(output, NULL);
        }
 }
 
@@ -338,8 +338,8 @@ TEST_P(TDMDisplay, DisplayGetOutputNullObject)
        tdm_error ret;
 
        output = tdm_display_get_output(NULL, 0, &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(TDMDisplay, DisplayGetOutputNullOther)
@@ -347,12 +347,12 @@ TEST_P(TDMDisplay, DisplayGetOutputNullOther)
        tdm_output *output;
        int o, count = TDM_UT_INVALID_VALUE;
 
-       ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
-       ASSERT_GT(count, 0);
+       EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
+       EXPECT_GT(count, 0);
 
        for (o = 0; o < count; o++) {
                output = tdm_display_get_output(dpy, o, NULL);
-               ASSERT_NE(output, NULL);
+               EXPECT_NE(output, NULL);
        }
 }
 
@@ -362,12 +362,12 @@ TEST_P(TDMDisplay, DisplayGetOutputWrongIndex)
        tdm_error ret;
 
        output = tdm_display_get_output(dpy, -1, &ret);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
-       ASSERT_EQ(output, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(output, NULL);
 
        output = tdm_display_get_output(dpy, INT_MAX, &ret);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
-       ASSERT_EQ(output, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(output, NULL);
 }
 
 TEST_P(TDMDisplay, DisplayFindOutput)
@@ -376,16 +376,16 @@ TEST_P(TDMDisplay, DisplayFindOutput)
        int count = TDM_UT_INVALID_VALUE;
        tdm_error ret;
 
-       ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
-       ASSERT_GT(count, 0);
+       EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
+       EXPECT_GT(count, 0);
 
        output = tdm_display_find_output(dpy, "primary", &ret);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
-       ASSERT_NE(output, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_NE(output, NULL);
 
        output = tdm_display_find_output(dpy, "invalid", &ret);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
-       ASSERT_EQ(output, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(output, NULL);
 }
 
 TEST_P(TDMDisplay, DisplayCreatePp)
@@ -397,8 +397,8 @@ TEST_P(TDMDisplay, DisplayCreatePp)
                return;
 
        pp = tdm_display_create_pp(dpy, &ret);
-       ASSERT_EQ(ret, TDM_ERROR_NONE);
-       ASSERT_NE(pp, NULL);
+       EXPECT_EQ(ret, TDM_ERROR_NONE);
+       EXPECT_NE(pp, NULL);
 
        tdm_pp_destroy(pp);
 }
@@ -412,8 +412,8 @@ TEST_P(TDMDisplay, DisplayCreatePpNullObject)
                return;
 
        pp = tdm_display_create_pp(NULL, &ret);
-       ASSERT_NE(ret, TDM_ERROR_NONE);
-       ASSERT_EQ(pp, NULL);
+       EXPECT_NE(ret, TDM_ERROR_NONE);
+       EXPECT_EQ(pp, NULL);
 }
 
 TEST_P(TDMDisplay, ModuleGetInfo)
@@ -422,8 +422,8 @@ TEST_P(TDMDisplay, ModuleGetInfo)
        int o, count = TDM_UT_INVALID_VALUE;
        tdm_error ret;
 
-       ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
-       ASSERT_GT(count, 0);
+       EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
+       EXPECT_GT(count, 0);
 
        for (o = 0; o < count; o++) {
                tdm_module *module;
@@ -433,18 +433,18 @@ TEST_P(TDMDisplay, ModuleGetInfo)
                int minor = TDM_UT_INVALID_VALUE;
 
                output = tdm_display_get_output(dpy, o, &ret);
-               ASSERT_EQ(ret, TDM_ERROR_NONE);
-               ASSERT_NE(output, NULL);
+               EXPECT_EQ(ret, TDM_ERROR_NONE);
+               EXPECT_NE(output, NULL);
 
                module = tdm_output_get_backend_module(output, &ret);
-               ASSERT_EQ(ret, TDM_ERROR_NONE);
-               ASSERT_NE(module, NULL);
-
-               ASSERT_EQ(tdm_module_get_info(module, &name, &vendor, &major, &minor), TDM_ERROR_NONE);
-               ASSERT_NE(name, (const char *)TDM_UT_INVALID_VALUE);
-               ASSERT_NE(vendor, (const char *)TDM_UT_INVALID_VALUE);
-               ASSERT_NE(major, TDM_UT_INVALID_VALUE);
-               ASSERT_NE(minor, TDM_UT_INVALID_VALUE);
+               EXPECT_EQ(ret, TDM_ERROR_NONE);
+               EXPECT_NE(module, NULL);
+
+               EXPECT_EQ(tdm_module_get_info(module, &name, &vendor, &major, &minor), TDM_ERROR_NONE);
+               EXPECT_NE(name, (const char *)TDM_UT_INVALID_VALUE);
+               EXPECT_NE(vendor, (const char *)TDM_UT_INVALID_VALUE);
+               EXPECT_NE(major, TDM_UT_INVALID_VALUE);
+               EXPECT_NE(minor, TDM_UT_INVALID_VALUE);
        }
 }
 
@@ -455,11 +455,11 @@ TEST_P(TDMDisplay, ModuleGetInfoNullObject)
        int major = TDM_UT_INVALID_VALUE;
        int minor = TDM_UT_INVALID_VALUE;
 
-       ASSERT_EQ(tdm_module_get_info(NULL, &name, &vendor, &major, &minor), TDM_ERROR_INVALID_PARAMETER);
-       ASSERT_EQ(name, (const char *)TDM_UT_INVALID_VALUE);
-       ASSERT_EQ(vendor, (const char *)TDM_UT_INVALID_VALUE);
-       ASSERT_EQ(major, TDM_UT_INVALID_VALUE);
-       ASSERT_EQ(minor, TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(tdm_module_get_info(NULL, &name, &vendor, &major, &minor), TDM_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(name, (const char *)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(vendor, (const char *)TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(major, TDM_UT_INVALID_VALUE);
+       EXPECT_EQ(minor, TDM_UT_INVALID_VALUE);
 }
 
 TEST_P(TDMDisplay, ModuleGetInfoNullOther)
@@ -468,21 +468,21 @@ TEST_P(TDMDisplay, ModuleGetInfoNullOther)
        int o, count = TDM_UT_INVALID_VALUE;
        tdm_error ret;
 
-       ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
-       ASSERT_GT(count, 0);
+       EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
+       EXPECT_GT(count, 0);
 
        for (o = 0; o < count; o++) {
                tdm_module *module;
 
                output = tdm_display_get_output(dpy, o, &ret);
-               ASSERT_EQ(ret, TDM_ERROR_NONE);
-               ASSERT_NE(output, NULL);
+               EXPECT_EQ(ret, TDM_ERROR_NONE);
+               EXPECT_NE(output, NULL);
 
                module = tdm_output_get_backend_module(output, &ret);
-               ASSERT_EQ(ret, TDM_ERROR_NONE);
-               ASSERT_NE(module, NULL);
+               EXPECT_EQ(ret, TDM_ERROR_NONE);
+               EXPECT_NE(module, NULL);
 
-               ASSERT_EQ(tdm_module_get_info(module, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
+               EXPECT_EQ(tdm_module_get_info(module, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
        }
 }