#include "ut_tdm.h"
+static void _ut_tdm_vblank_create_cb(tdm_vblank *vblank, void *user_data);
+static void _ut_tdm_vblank_create_cb2(tdm_vblank *vblank, void *user_data);
+
class TDMVblank : public TDMOutput
{
public:
void TDMVblank::TearDown(void)
{
+ tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this);
+ tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL);
+ tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb2, this);
+ tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb2, NULL);
+
TestDestroyVblanks();
tdm_vblank_enable_global_fps(0, 0);
if (!ut_tdm_output_is_connected(outputs[o]))
continue;
- TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_output_prepare(dpy, outputs[o]) == true);
+ TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_output_prepare(dpy, outputs[o], false) == true);
}
return true;
TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
+ /* only check if connected */
return ut_tdm_output_is_connected(output);
}
-#ifdef UT_TDM_VBLANK_ENABLE
-
/* tdm_vblank_set_client_vblank_fps */
TEST_P(TDMVblank, DISABLED_VblankSetClientVblankFps)
{
TEST_P(TDMVblank, VblankSetClientVblankFpsNullObject)
{
- ASSERT_TRUE(tdm_vblank_set_client_vblank_fps(0, NULL, 60) == TDM_ERROR_INVALID_PARAMETER);
- ASSERT_TRUE(tdm_vblank_set_client_vblank_fps(123, NULL, 0) == TDM_ERROR_INVALID_PARAMETER);
+ 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);
}
/* tdm_vblank_set_client_vblank_fps */
TEST_P(TDMVblank, VblankSetClientIgnoreGlobalFpsNullObject)
{
- ASSERT_TRUE(tdm_vblank_set_client_ignore_global_fps(0, NULL, 0) == TDM_ERROR_INVALID_PARAMETER);
- ASSERT_TRUE(tdm_vblank_set_client_ignore_global_fps(0, NULL, 1) == TDM_ERROR_INVALID_PARAMETER);
+ 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);
}
/* tdm_vblank_create() */
for (int o = 0; o < output_count; o++) {
tdm_error ret;
tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
- ASSERT_TRUE(ret == TDM_ERROR_NONE);
- ASSERT_TRUE(vblank != NULL);
+ ASSERT_EQ(ret, TDM_ERROR_NONE);
+ ASSERT_NE(vblank, NULL);
tdm_vblank_destroy(vblank);
}
tdm_error ret;
tdm_vblank *vblank = tdm_vblank_create(NULL, outputs[0], &ret);
- ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER);
- ASSERT_TRUE(vblank == NULL);
+ ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(vblank, NULL);
}
TEST_P(TDMVblank, VblankCreateNullOutput)
tdm_error ret;
tdm_vblank *vblank = tdm_vblank_create(dpy, NULL, &ret);
- ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER);
- ASSERT_TRUE(vblank == NULL);
+ ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(vblank, NULL);
}
TEST_P(TDMVblank, VblankCreateNullOther)
TDM_UT_SKIP_FLAG(has_outputs);
tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[0], NULL);
- ASSERT_TRUE(vblank != NULL);
+ ASSERT_NE(vblank, NULL);
tdm_vblank_destroy(vblank);
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
for (int o = 0; o < output_count; o++) {
tdm_error ret;
done = false;
tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
- ASSERT_TRUE(ret == TDM_ERROR_NONE);
- ASSERT_TRUE(vblank != NULL);
- ASSERT_TRUE(done == true);
+ ASSERT_EQ(ret, TDM_ERROR_NONE);
+ ASSERT_NE(vblank, NULL);
+ ASSERT_EQ(done, true);
tdm_vblank_destroy(vblank);
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL) == TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL) == TDM_ERROR_BAD_REQUEST);
+ ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL), TDM_ERROR_BAD_REQUEST);
}
TEST_P(TDMVblank, VblankAddCreateHandlerNullObject)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(tdm_vblank_add_create_handler(NULL, _ut_tdm_vblank_create_cb, NULL) == TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_vblank_add_create_handler(NULL, _ut_tdm_vblank_create_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMVblank, VblankAddCreateHandlerNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(tdm_vblank_add_create_handler(dpy, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_vblank_add_create_handler(dpy, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
/* tdm_vblank_remove_create_handler */
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this);
for (int o = 0; o < output_count; o++) {
done = false;
tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
- ASSERT_TRUE(ret == TDM_ERROR_NONE);
- ASSERT_TRUE(vblank != NULL);
- ASSERT_TRUE(done == false);
+ ASSERT_EQ(ret, TDM_ERROR_NONE);
+ ASSERT_NE(vblank, NULL);
+ ASSERT_EQ(done, false);
tdm_vblank_destroy(vblank);
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this);
tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this);
done = false;
tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
- ASSERT_TRUE(ret == TDM_ERROR_NONE);
- ASSERT_TRUE(vblank != NULL);
- ASSERT_TRUE(done == false);
+ ASSERT_EQ(ret, TDM_ERROR_NONE);
+ ASSERT_NE(vblank, NULL);
+ ASSERT_EQ(done, false);
tdm_vblank_destroy(vblank);
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL);
done = false;
tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
- ASSERT_TRUE(ret == TDM_ERROR_NONE);
- ASSERT_TRUE(vblank != NULL);
- ASSERT_TRUE(done == true);
+ ASSERT_EQ(ret, TDM_ERROR_NONE);
+ ASSERT_NE(vblank, NULL);
+ ASSERT_EQ(done, true);
tdm_vblank_destroy(vblank);
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb2, this) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb2, this), TDM_ERROR_NONE);
for (int o = 0; o < output_count; o++) {
tdm_error ret;
done = false;
tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
- ASSERT_TRUE(ret == TDM_ERROR_NONE);
- ASSERT_TRUE(vblank != NULL);
+ ASSERT_EQ(ret, TDM_ERROR_NONE);
+ ASSERT_NE(vblank, NULL);
if (o == 0)
- ASSERT_TRUE(done == true);
+ ASSERT_EQ(done, true);
else
- ASSERT_TRUE(done == false);
+ ASSERT_EQ(done, false);
tdm_vblank_destroy(vblank);
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
tdm_error ret;
- ASSERT_TRUE(tdm_vblank_get_output(vblanks[v], &ret) != NULL);
- ASSERT_TRUE(ret == TDM_ERROR_NONE);
+ ASSERT_NE(tdm_vblank_get_output(vblanks[v], &ret), NULL);
+ ASSERT_EQ(ret, TDM_ERROR_NONE);
}
}
TEST_P(TDMVblank, VblankGetOutputNullObject)
{
tdm_error ret;
- ASSERT_TRUE(tdm_vblank_get_output(NULL, &ret) == NULL);
- ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_vblank_get_output(NULL, &ret), NULL);
+ ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMVblank, VblankGetOutputNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
- ASSERT_TRUE(tdm_vblank_get_output(vblanks[0], NULL) != NULL);
+ ASSERT_NE(tdm_vblank_get_output(vblanks[0], NULL), NULL);
}
/* tdm_vblank_get_client_pid() */
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
pid_t pid = (pid_t)TDM_UT_INVALID_VALUE;
- ASSERT_TRUE(tdm_vblank_get_client_pid(vblanks[v], &pid) == TDM_ERROR_NONE);
+ ASSERT_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_TRUE(pid == 0);
+ ASSERT_EQ(pid, 0);
}
}
TEST_P(TDMVblank, VblankGetClientPidNullObject)
{
pid_t pid = (pid_t)TDM_UT_INVALID_VALUE;
- ASSERT_TRUE(tdm_vblank_get_client_pid(NULL, &pid) == TDM_ERROR_INVALID_PARAMETER);
- ASSERT_TRUE(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);
}
TEST_P(TDMVblank, VblankGetClientPidNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
- ASSERT_TRUE(tdm_vblank_get_client_pid(vblanks[0], NULL) == TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_vblank_get_client_pid(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
/* tdm_vblank_set_name() */
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++)
- ASSERT_TRUE(tdm_vblank_set_name(vblanks[v], TDM_UT_VBLANK_NAME) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_set_name(vblanks[v], TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
}
TEST_P(TDMVblank, VblankSetNameNullObject)
{
- ASSERT_TRUE(tdm_vblank_set_name(NULL, TDM_UT_VBLANK_NAME) == TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_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_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++)
- ASSERT_TRUE(tdm_vblank_set_name(vblanks[v], NULL) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_set_name(vblanks[v], NULL), TDM_ERROR_NONE);
}
/* tdm_vblank_get_name() */
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
const char *name = (const char *)TDM_UT_INVALID_VALUE;
- ASSERT_TRUE(tdm_vblank_set_name(vblanks[v], TDM_UT_VBLANK_NAME) == TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_vblank_get_name(vblanks[v], &name) == TDM_ERROR_NONE);
+ 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);
}
}
TEST_P(TDMVblank, VblankGetNameNullObject)
{
const char *name = (const char *)TDM_UT_INVALID_VALUE;
- ASSERT_TRUE(tdm_vblank_get_name(NULL, &name) == TDM_ERROR_INVALID_PARAMETER);
- ASSERT_TRUE(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);
}
TEST_P(TDMVblank, VblankGetNameNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
- ASSERT_TRUE(tdm_vblank_get_name(vblanks[0], NULL) == TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_vblank_get_name(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMVblank, VblankGetNameNoSet)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
const char *name = (const char *)TDM_UT_INVALID_VALUE;
- ASSERT_TRUE(tdm_vblank_get_name(vblanks[v], &name) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_get_name(vblanks[v], &name), TDM_ERROR_NONE);
ASSERT_STREQ(name, TDM_VBLANK_DEFAULT_NAME);
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++)
- ASSERT_TRUE(tdm_vblank_set_fps(vblanks[v], 60) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
}
TEST_P(TDMVblank, VblankSetFpsNullObject)
{
- ASSERT_TRUE(tdm_vblank_set_fps(NULL, 60) == TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_vblank_set_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMVblank, VblankSetFpsTwice)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
- ASSERT_TRUE(tdm_vblank_set_fps(vblanks[v], 60) == TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_vblank_set_fps(vblanks[v], 60) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++)
- ASSERT_TRUE(tdm_vblank_set_fixed_fps(vblanks[v], 60) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE);
}
TEST_P(TDMVblank, VblankSetFixedFpsNullObject)
{
- ASSERT_TRUE(tdm_vblank_set_fixed_fps(NULL, 60) == TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_vblank_set_fixed_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMVblank, VblankSetFixedFpsTwice)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
- ASSERT_TRUE(tdm_vblank_set_fixed_fps(vblanks[v], 60) == TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_vblank_set_fixed_fps(vblanks[v], 60) == TDM_ERROR_NONE);
+ 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);
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_TRUE(tdm_vblank_set_fps(vblanks[v], 60) == TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == TDM_ERROR_NONE);
- ASSERT_TRUE(fps == 60);
+ 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);
}
}
TEST_P(TDMVblank, VblankGetFpsNullObject)
{
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_TRUE(tdm_vblank_get_fps(NULL, &fps) == TDM_ERROR_INVALID_PARAMETER);
- ASSERT_TRUE(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);
}
TEST_P(TDMVblank, VblankGetFpsNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
- ASSERT_TRUE(tdm_vblank_get_fps(vblanks[0], NULL) == TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMVblank, VblankGetFpsNoSet)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestPrepareOutput() == true);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestPrepareOutput(), true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
continue;
- ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == 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);
tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
- ASSERT_TRUE(output != NULL);
- ASSERT_TRUE(ret == TDM_ERROR_NONE);
+ ASSERT_NE(output, NULL);
+ ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_output_get_mode(output, &mode) == 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);
- ASSERT_TRUE(fps == mode->vrefresh);
+ ASSERT_EQ(fps, mode->vrefresh);
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_TRUE(tdm_vblank_set_fps(vblanks[v], 60) == TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == TDM_ERROR_NONE);
- ASSERT_TRUE(fps == 60);
+ 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);
- ASSERT_TRUE(tdm_vblank_set_fixed_fps(vblanks[v], 10) == TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == TDM_ERROR_NONE);
- ASSERT_TRUE(fps == 10);
+ 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);
/* 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_TRUE(tdm_vblank_set_fps(vblanks[v], 60) == TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == TDM_ERROR_NONE);
- ASSERT_TRUE(fps == 10);
+ 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);
}
}
/* tdm_vblank_ignore_global_fps() */
TEST_P(TDMVblank, VblankIgnoreGlobalFpsNullObject)
{
- ASSERT_TRUE(tdm_vblank_ignore_global_fps(NULL, 1) == TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_vblank_ignore_global_fps(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMVblank, VblankIgnoreGlobalFpsSet)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++)
- ASSERT_TRUE(tdm_vblank_ignore_global_fps(vblanks[v], 1) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE);
}
TEST_P(TDMVblank, VblankIgnoreGlobalFpsSetTwice)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
- ASSERT_TRUE(tdm_vblank_ignore_global_fps(vblanks[v], 1) == TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_vblank_ignore_global_fps(vblanks[v], 1) == TDM_ERROR_NONE);
+ 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);
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++)
- ASSERT_TRUE(tdm_vblank_ignore_global_fps(vblanks[v], 0) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE);
}
TEST_P(TDMVblank, VblankIgnoreGlobalFpsUnsetTwice)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
- ASSERT_TRUE(tdm_vblank_ignore_global_fps(vblanks[v], 0) == TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_vblank_ignore_global_fps(vblanks[v], 0) == TDM_ERROR_NONE);
+ 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);
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++)
- ASSERT_TRUE(tdm_vblank_set_offset(vblanks[v], 10) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
}
TEST_P(TDMVblank, VblankSetOffsetNullObject)
{
- ASSERT_TRUE(tdm_vblank_set_offset(NULL, 10) == TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMVblank, VblankSetOffsetTwice)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
- ASSERT_TRUE(tdm_vblank_set_offset(vblanks[v], 10) == TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_vblank_set_offset(vblanks[v], 10) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
int offset = TDM_UT_INVALID_VALUE;
- ASSERT_TRUE(tdm_vblank_set_offset(vblanks[v], 10) == TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_vblank_get_offset(vblanks[v], &offset) == TDM_ERROR_NONE);
- ASSERT_TRUE(offset == 10);
+ 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);
}
}
TEST_P(TDMVblank, VblankGetOffsetNullObject)
{
int offset = TDM_UT_INVALID_VALUE;
- ASSERT_TRUE(tdm_vblank_get_offset(NULL, &offset) == TDM_ERROR_INVALID_PARAMETER);
- ASSERT_TRUE(offset == TDM_UT_INVALID_VALUE);
+ ASSERT_EQ(tdm_vblank_get_offset(NULL, &offset), TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(offset, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMVblank, VblankGetOffsetNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
- ASSERT_TRUE(tdm_vblank_get_offset(vblanks[0], NULL) == TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_vblank_get_offset(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMVblank, VblankGetOffsetNoSet)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
int offset = TDM_UT_INVALID_VALUE;
- ASSERT_TRUE(tdm_vblank_get_offset(vblanks[v], &offset) == TDM_ERROR_NONE);
- ASSERT_TRUE(offset == 0);
+ ASSERT_EQ(tdm_vblank_get_offset(vblanks[v], &offset), TDM_ERROR_NONE);
+ ASSERT_EQ(offset, 0);
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++)
- ASSERT_TRUE(tdm_vblank_set_enable_fake(vblanks[v], 1) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
}
TEST_P(TDMVblank, VblankSetEnableFakeNullObject)
{
- ASSERT_TRUE(tdm_vblank_set_enable_fake(NULL, 1) == TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMVblank, VblankSetEnableFakeTwice)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
- ASSERT_TRUE(tdm_vblank_set_enable_fake(vblanks[v], 1) == TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_vblank_set_enable_fake(vblanks[v], 1) == TDM_ERROR_NONE);
+ 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);
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
unsigned int enable_fake;
- ASSERT_TRUE(tdm_vblank_set_enable_fake(vblanks[v], 1) == TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake) == TDM_ERROR_NONE);
- ASSERT_TRUE(enable_fake == 1);
+ 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);
- ASSERT_TRUE(tdm_vblank_set_enable_fake(vblanks[v], 0) == TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake) == TDM_ERROR_NONE);
- ASSERT_TRUE(enable_fake == 0);
+ 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);
}
}
TEST_P(TDMVblank, VblankGetEnableFakeNullObject)
{
unsigned int enable_fake = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_TRUE(tdm_vblank_get_enable_fake(NULL, &enable_fake) == TDM_ERROR_INVALID_PARAMETER);
- ASSERT_TRUE(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);
}
TEST_P(TDMVblank, VblankGetEnableFakeNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
- ASSERT_TRUE(tdm_vblank_get_enable_fake(vblanks[0], NULL) == TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMVblank, VblankGetEnableFakeNoSet)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
unsigned int enable_fake;
- ASSERT_TRUE(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake) == TDM_ERROR_NONE);
- ASSERT_TRUE(enable_fake == 0);
+ ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE);
+ ASSERT_EQ(enable_fake, 0);
}
}
{
unsigned int *cur_seq = (unsigned int *)user_data;
if (cur_seq)
- *cur_seq = sequence;
+ *cur_seq = (error == TDM_ERROR_NONE) ? sequence : ((unsigned int)-1);
}
TEST_P(TDMVblank, VblankWait)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestPrepareOutput() == true);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestPrepareOutput(), true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
continue;
- ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == 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);
interval = 1.0 / (double)fps;
unsigned int cur_seq = 0;
start = tdm_helper_get_time();
- ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
while (cur_seq == 0)
- ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
+ ASSERT_EQ(ut_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_TRUE((end - start) < (interval + interval));
+ ASSERT_LT((end - start), (interval + interval));
}
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestPrepareOutput() == true);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestPrepareOutput(), true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
continue;
- ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == 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);
interval = 1.0 / (double)fps;
cur_seq = seq1 = seq2 = 0;
start = tdm_helper_get_time();
- ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &seq1) == TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &seq2) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &seq1), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &seq2), TDM_ERROR_NONE);
while (cur_seq == 0)
- ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
+ ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
end = tdm_helper_get_time();
- ASSERT_TRUE(seq1 != 0);
- ASSERT_TRUE(seq2 != 0);
+ ASSERT_NE(seq1, 0);
+ ASSERT_NE(seq2, 0);
/* "+ interval" consider the delay of socket communication between kernel and platform */
- ASSERT_TRUE((end - start) < (interval + interval));
+ ASSERT_LT((end - start), (interval + interval));
}
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestPrepareOutput() == true);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestPrepareOutput(), true);
+ ASSERT_EQ(TestCreateVblanks(), true);
- ASSERT_TRUE(tdm_vblank_wait(vblanks[0], 0, 0, 0, _ut_tdm_vblank_cb, NULL) == TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, _ut_tdm_vblank_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMVblank, VblankWaitInterval)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestPrepareOutput() == true);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestPrepareOutput(), true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
continue;
- ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == 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);
interval = 1.0 / (double)fps;
unsigned int cur_seq = 0;
start = tdm_helper_get_time();
- ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, t, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, t, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
while (cur_seq == 0)
- ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
+ ASSERT_EQ(ut_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_TRUE((end - start) > interval * (t - 1));
- ASSERT_TRUE((end - start) < interval * t + interval);
+ ASSERT_GT((end - start), interval * (t - 1));
+ ASSERT_LT((end - start), interval * t + interval);
}
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestPrepareOutput() == true);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestPrepareOutput(), true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
continue;
- ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == 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);
interval = 1.0 / (double)fps;
for (int t = 0; t < 10; t++) {
unsigned int cur_seq = 0, temp = 0;
- ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
while (cur_seq == 0)
- ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
+ ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
start = tdm_helper_get_time();
- ASSERT_TRUE(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + 1, _ut_tdm_vblank_cb, &temp) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + 1, _ut_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
while (temp == 0)
- ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
+ ASSERT_EQ(ut_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_TRUE((end - start) < (interval + interval));
+ ASSERT_LT((end - start), (interval + interval));
}
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestPrepareOutput() == true);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestPrepareOutput(), true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
continue;
- ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == 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);
interval = 1.0 / (double)fps;
for (int t = 1; t < 10; t++) {
unsigned int cur_seq = 0, temp = 0;
- ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
while (cur_seq == 0)
- ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
+ ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
start = tdm_helper_get_time();
- ASSERT_TRUE(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + t, _ut_tdm_vblank_cb, &temp) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + t, _ut_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
while (temp == 0)
- ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
+ ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
end = tdm_helper_get_time();
-#if 0
-printf("@@@ %s(%d) cur_seq(%d) t(%d) start(%.6f) end(%.6f) diff(%.6f) (%.6f~%.6f)\n",
- __FUNCTION__, __LINE__, cur_seq, t, start, end, end - start, (interval * (t - 1)), (interval * t + interval));
-#endif
-
/* "+ interval" consider the delay of socket communication between kernel and platform */
- ASSERT_TRUE((end - start) > (interval * (t - 1)));
- ASSERT_TRUE((end - start) < (interval * t + interval));
+ ASSERT_GT((end - start), (interval * (t - 1)));
+ ASSERT_LT((end - start), (interval * t + interval));
}
}
}
unsigned int cur_seq = 0;
- ASSERT_TRUE(tdm_vblank_wait(NULL, 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_vblank_wait(NULL, 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMVblank, VblankWaitNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestCreateVblanks(), true);
- ASSERT_TRUE(tdm_vblank_wait(vblanks[0], 0, 0, 0, NULL, NULL) == TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_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_TRUE(TestPrepareOutput() == true);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestPrepareOutput(), true);
+ ASSERT_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_TRUE(ret == TDM_ERROR_NONE);
+ ASSERT_EQ(ret, TDM_ERROR_NONE);
if (!ut_tdm_output_is_connected(output))
continue;
- ASSERT_TRUE(ut_tdm_output_unset(dpy, output) == true);
+ ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE);
-
- ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL) == TDM_ERROR_DPMS_OFF);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_DPMS_OFF);
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestPrepareOutput() == true);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestPrepareOutput(), true);
+ ASSERT_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_TRUE(ret == TDM_ERROR_NONE);
+ ASSERT_EQ(ret, TDM_ERROR_NONE);
if (!ut_tdm_output_is_connected(output))
continue;
- ASSERT_TRUE(ut_tdm_output_unset(dpy, output) == true);
-
- ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &temp) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
while (temp == 0)
- ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
+ ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestPrepareOutput() == true);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestPrepareOutput(), true);
+ ASSERT_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_TRUE(ret == TDM_ERROR_NONE);
+ ASSERT_EQ(ret, TDM_ERROR_NONE);
if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
continue;
if (!ut_tdm_output_is_connected(output))
continue;
- ASSERT_TRUE(ut_tdm_output_unset(dpy, output) == true);
+ ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
- ASSERT_TRUE(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);
- ASSERT_TRUE(tdm_vblank_set_enable_fake(vblanks[v], 1) == TDM_ERROR_NONE);
-
- ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_NONE);
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestPrepareOutput() == true);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestPrepareOutput(), true);
+ ASSERT_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_TRUE(ret == TDM_ERROR_NONE);
+ ASSERT_EQ(ret, TDM_ERROR_NONE);
if (ut_tdm_output_is_connected(output))
continue;
- ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL) == TDM_ERROR_OUTPUT_DISCONNECTED);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_OUTPUT_DISCONNECTED);
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestPrepareOutput() == true);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestPrepareOutput(), true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
continue;
- ASSERT_TRUE(tdm_vblank_set_offset(vblanks[v], 100) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 100), TDM_ERROR_NONE);
- ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == 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);
interval = 1.0 / (double)fps;
unsigned int cur_seq = 0;
start = tdm_helper_get_time();
- ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
while (cur_seq == 0)
- ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
+ ASSERT_EQ(ut_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_TRUE((end - start) > (0.1));
- ASSERT_TRUE((end - start) < (interval + interval + 0.1));
+ ASSERT_GT((end - start), (0.1));
+ ASSERT_LT((end - start), (interval + interval + 0.1));
}
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestPrepareOutput() == true);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestPrepareOutput(), true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
continue;
- ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == 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);
vrefresh_interval = 1.0 / (double)fps;
fps /= 2;
- ASSERT_TRUE(tdm_vblank_set_fps(vblanks[v], fps) == TDM_ERROR_NONE);
+ ASSERT_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_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
while (cur_seq == 0)
- ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
+ ASSERT_EQ(ut_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_TRUE((end - start) > (interval - vrefresh_interval));
- ASSERT_TRUE((end - start) < (interval + vrefresh_interval));
+ ASSERT_GT((end - start), (interval - vrefresh_interval));
+ ASSERT_LT((end - start), (interval + vrefresh_interval));
}
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestPrepareOutput() == true);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestPrepareOutput(), true);
+ ASSERT_EQ(TestCreateVblanks(), true);
for (int v = 0; v < vblank_count; v++) {
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
continue;
- ASSERT_TRUE(tdm_vblank_get_fps(vblanks[v], &fps) == 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);
interval = 1.0 / (double)fps;
- ASSERT_TRUE(tdm_vblank_set_fixed_fps(vblanks[v], fps) == TDM_ERROR_NONE);
+ ASSERT_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_TRUE(tdm_vblank_set_fps(vblanks[v], fps) == TDM_ERROR_NONE);
+ ASSERT_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_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
while (cur_seq == 0)
- ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
+ ASSERT_EQ(ut_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_TRUE((end - start) < (interval + interval));
+ ASSERT_LT((end - start), (interval + interval));
}
}
}
unsigned int global_fps = 5;
double start, end, interval;
- ASSERT_TRUE(TestPrepareOutput() == true);
- ASSERT_TRUE(TestCreateVblanks3() == true);
- ASSERT_TRUE(vblank_count == 3);
+ ASSERT_EQ(TestPrepareOutput(), true);
+ ASSERT_EQ(TestCreateVblanks3(), true);
+ ASSERT_EQ(vblank_count, 3);
if (!ut_tdm_vblank_is_avaiable(vblanks[0]))
return;
- ASSERT_TRUE(tdm_vblank_get_fps(vblanks[0], &fps) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE);
ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
vrefresh_interval = 1.0 / (double)fps;
for (int v = 0; v < 3; v++) {
- ASSERT_TRUE(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)), TDM_ERROR_NONE);
interval = 1.0 / (double)(10 * (v + 1));
}
for (int v = 0; v < 3; v++) {
cur_seq[v] = 0;
- ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
}
start = tdm_helper_get_time();
while (cur_seq[2] == 0)
- ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
+ ASSERT_EQ(ut_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_TRUE((end - start) > (interval - vrefresh_interval));
- ASSERT_TRUE((end - start) < (interval + vrefresh_interval));
+ ASSERT_GT((end - start), (interval - vrefresh_interval));
+ ASSERT_LT((end - start), (interval + vrefresh_interval));
- ASSERT_TRUE(cur_seq[1] == 0);
- ASSERT_TRUE(cur_seq[0] == 0);
+ ASSERT_EQ(cur_seq[1], 0);
+ ASSERT_EQ(cur_seq[0], 0);
while (cur_seq[1] == 0)
- ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
- ASSERT_TRUE(cur_seq[0] == 0);
+ ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(cur_seq[0], 0);
while (cur_seq[0] == 0)
- ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
+ ASSERT_EQ(ut_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_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
}
while (cur_seq[2] == 0)
- ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
- ASSERT_TRUE(cur_seq[1] == 0);
- ASSERT_TRUE(cur_seq[0] == 0);
+ ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(cur_seq[1], 0);
+ ASSERT_EQ(cur_seq[0], 0);
while (cur_seq[1] == 0)
- ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
- ASSERT_TRUE(cur_seq[0] == 0);
+ ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(cur_seq[0], 0);
}
TEST_P(TDMVblank, VblankWaitSetEnableFakeDisconnected)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_TRUE(TestPrepareOutput() == true);
- ASSERT_TRUE(TestCreateVblanks() == true);
+ ASSERT_EQ(TestPrepareOutput(), true);
+ ASSERT_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_TRUE(ret == TDM_ERROR_NONE);
+ ASSERT_EQ(ret, TDM_ERROR_NONE);
if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
continue;
if (ut_tdm_output_is_connected(output))
continue;
- ASSERT_TRUE(tdm_vblank_set_enable_fake(vblanks[v], 1) == TDM_ERROR_DPMS_OFF);
+ ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_DPMS_OFF);
- ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL) == TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_NONE);
}
}
+TEST_P(TDMVblank, DISABLED_VblankWaitBeforeDpmsOff)
+{
+ /* wait vblank -> dpms off -> then? (vblank handler is called? or not?) */
+}
+
+#ifdef TDM_UT_TEST_WITH_PARAMS
INSTANTIATE_TEST_CASE_P(TDMVblankParams,
TDMVblank,
Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
-
-#endif
+#else
+INSTANTIATE_TEST_CASE_P(TDMVblankParams,
+ TDMVblank,
+ Values(TDM_DEFAULT_MODULE));
+#endif
\ No newline at end of file
projects / platform / core / uifw / libtdm.git / blobdiff