TearDown is not called at testcase failed when it uses ASSERT.
Change-Id: Id6da7da47265a1aac9e72c628a411bf0ea0c4e2e
TDMBackendDisplay::SetUp();
- ASSERT_EQ(tdm_display_get_capabilities(dpy, &dpy_capabilities), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_display_get_capabilities(dpy, &dpy_capabilities), TDM_ERROR_NONE);
has_capture_cap = dpy_capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE;
if (!has_capture_cap)
return;
- ASSERT_EQ(tdm_display_get_capture_capabilities(dpy, &capabilities), TDM_ERROR_NONE);
- ASSERT_GT(capabilities, 0);
- ASSERT_EQ(tdm_display_get_capture_available_formats(dpy, &formats, &format_count), TDM_ERROR_NONE);
- ASSERT_NE(formats, NULL);
- ASSERT_GT(format_count, 0);
- ASSERT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
- ASSERT_TRUE(min_w == -1 || min_w > 0);
- ASSERT_TRUE(min_h == -1 || min_h > 0);
- ASSERT_TRUE(max_w == -1 || max_w > 0);
- ASSERT_TRUE(max_h == -1 || max_h > 0);
- ASSERT_TRUE(preferred_align == -1 || preferred_align > 0);
+ EXPECT_EQ(tdm_display_get_capture_capabilities(dpy, &capabilities), TDM_ERROR_NONE);
+ EXPECT_GT(capabilities, 0);
+ EXPECT_EQ(tdm_display_get_capture_available_formats(dpy, &formats, &format_count), TDM_ERROR_NONE);
+ EXPECT_NE(formats, NULL);
+ EXPECT_GT(format_count, 0);
+ EXPECT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
+ EXPECT_TRUE(min_w == -1 || min_w > 0);
+ EXPECT_TRUE(min_h == -1 || min_h > 0);
+ EXPECT_TRUE(max_w == -1 || max_w > 0);
+ EXPECT_TRUE(max_h == -1 || max_h > 0);
+ EXPECT_TRUE(preferred_align == -1 || preferred_align > 0);
for (int o = 0; o < output_count; o++) {
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
}
DestroyBuffers();
void TDMBackendCapture::ShowBuffer(int b, tdm_pos *pos)
{
- ASSERT_NE(output, NULL);
- ASSERT_NE(dst_layer, NULL);
+ EXPECT_NE(output, NULL);
+ EXPECT_NE(dst_layer, NULL);
- ASSERT_EQ(tc_tdm_layer_set_buffer_with_pos(dst_layer, buffers[b], pos), true);
- ASSERT_EQ(tdm_output_commit(output, 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer_with_pos(dst_layer, buffers[b], pos), true);
+ EXPECT_EQ(tdm_output_commit(output, 0, NULL, NULL), TDM_ERROR_NONE);
}
void TDMBackendCapture::HideLayer(void)
{
- ASSERT_NE(output, NULL);
- ASSERT_NE(dst_layer, NULL);
+ EXPECT_NE(output, NULL);
+ EXPECT_NE(dst_layer, NULL);
tdm_layer_unset_buffer(dst_layer);
tdm_output_commit(output, 0, NULL, NULL);
const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
if (has_capture_cap) {
- ASSERT_EQ(tdm_display_get_capture_available_formats(dpy, &formats, &count), TDM_ERROR_NONE);
- ASSERT_TRUE(formats != NULL && formats != (const tbm_format *)TDM_UT_INVALID_VALUE);
- ASSERT_TRUE(count > 0 && count != TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_display_get_capture_available_formats(dpy, &formats, &count), TDM_ERROR_NONE);
+ EXPECT_TRUE(formats != NULL && formats != (const tbm_format *)TDM_UT_INVALID_VALUE);
+ EXPECT_TRUE(count > 0 && count != TDM_UT_INVALID_VALUE);
} else {
- ASSERT_EQ(tdm_display_get_capture_available_formats(dpy, &formats, &count), TDM_ERROR_NO_CAPABILITY);
- ASSERT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE);
- ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_display_get_capture_available_formats(dpy, &formats, &count), TDM_ERROR_NO_CAPABILITY);
+ EXPECT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
}
}
{
const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_display_get_capture_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE);
- ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_display_get_capture_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableFormatsNullOther)
{
- ASSERT_EQ(tdm_display_get_capture_available_formats(dpy, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_display_get_capture_available_formats(dpy, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableSize)
int max_h = TDM_UT_INVALID_VALUE;
int preferred_align = TDM_UT_INVALID_VALUE;
if (has_capture_cap) {
- ASSERT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
- ASSERT_NE(min_w, TDM_UT_INVALID_VALUE);
- ASSERT_NE(min_h, TDM_UT_INVALID_VALUE);
- ASSERT_NE(max_w, TDM_UT_INVALID_VALUE);
- ASSERT_NE(max_h, TDM_UT_INVALID_VALUE);
- ASSERT_NE(preferred_align, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
+ EXPECT_NE(min_w, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(min_h, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(max_w, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(max_h, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(preferred_align, TDM_UT_INVALID_VALUE);
} else {
- ASSERT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NO_CAPABILITY);
- ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NO_CAPABILITY);
+ EXPECT_EQ(min_w, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(min_h, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(max_w, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(max_h, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
}
}
int max_w = TDM_UT_INVALID_VALUE;
int max_h = TDM_UT_INVALID_VALUE;
int preferred_align = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_display_get_capture_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_display_get_capture_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(min_w, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(min_h, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(max_w, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(max_h, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMBackendCapture, CaptureDispalyGetAvaiableSizeNullOther)
{
if (has_capture_cap)
- ASSERT_EQ(tdm_display_get_capture_available_size(dpy, NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_display_get_capture_available_size(dpy, NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
else
- ASSERT_EQ(tdm_display_get_capture_available_size(dpy, NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NO_CAPABILITY);
+ EXPECT_EQ(tdm_display_get_capture_available_size(dpy, NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NO_CAPABILITY);
}
TEST_P(TDMBackendCapture, CaptureDestroy)
TDM_UT_SKIP_FLAG(has_capture_cap);
TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT);
- ASSERT_EQ(TestPrepareDefault(), true);
+ EXPECT_EQ(TestPrepareDefault(), true);
TestDone();
}
tdm_info_capture info;
memset(&info, 0, sizeof info);
- ASSERT_EQ(tdm_capture_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_capture_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMBackendCapture, CaptureSetInfoNullOther)
TDM_UT_SKIP_FLAG(has_capture_cap);
TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT);
- ASSERT_EQ(TestPrepareDefault(), true);
+ EXPECT_EQ(TestPrepareDefault(), true);
- ASSERT_EQ(tdm_capture_set_info(capture, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_capture_set_info(capture, NULL), TDM_ERROR_INVALID_PARAMETER);
TestDone();
}
TDM_UT_SKIP_FLAG(has_capture_cap);
TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT);
- ASSERT_EQ(TestPrepareDefault(), true);
+ EXPECT_EQ(TestPrepareDefault(), true);
- ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, NULL), TDM_ERROR_NONE);
TestDone();
}
TDM_UT_SKIP_FLAG(has_capture_cap);
TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT);
- ASSERT_EQ(tdm_capture_set_done_handler(NULL, _tc_tdm_capture_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_capture_set_done_handler(NULL, _tc_tdm_capture_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMBackendCapture, CaptureSetDoneHandlerNullOther)
TDM_UT_SKIP_FLAG(has_capture_cap);
TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT);
- ASSERT_EQ(TestPrepareDefault(), true);
+ EXPECT_EQ(TestPrepareDefault(), true);
- ASSERT_EQ(tdm_capture_set_done_handler(capture, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_capture_set_done_handler(capture, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
TestDone();
}
else
FindLayer(o, formats[f], &dst_pos);
- ASSERT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
+ EXPECT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true);
for (int b = 0; b < 3; b++)
- ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE);
TestDone();
}
tbm_surface_h buffer = (tbm_surface_h)TDM_UT_BUFFER_SIZE;
- ASSERT_EQ(tdm_capture_attach(NULL, buffer), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_capture_attach(NULL, buffer), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMBackendCapture, CaptureAttachNullOther)
TDM_UT_SKIP_FLAG(has_capture_cap);
TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT);
- ASSERT_EQ(TestPrepareDefault(), true);
+ EXPECT_EQ(TestPrepareDefault(), true);
- ASSERT_EQ(tdm_capture_attach(capture, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_capture_attach(capture, NULL), TDM_ERROR_INVALID_PARAMETER);
TestDone();
}
TDM_UT_SKIP_FLAG(has_capture_cap);
TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT);
- ASSERT_EQ(TestPrepareDefault(), true);
+ EXPECT_EQ(TestPrepareDefault(), true);
- ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
TestDone();
}
TDM_UT_SKIP_FLAG(has_capture_cap);
TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT);
- ASSERT_EQ(tdm_capture_commit(NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_capture_commit(NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMBackendCapture, CaptureCommitDpmsOff)
TDM_UT_SKIP_FLAG(has_capture_cap);
TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT);
- ASSERT_EQ(TestPrepareDefault(), true);
+ EXPECT_EQ(TestPrepareDefault(), true);
- ASSERT_EQ(tc_tdm_output_unset(dpy, output), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, output), true);
- 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_capture_commit(capture), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_capture_commit(capture), TDM_ERROR_BAD_REQUEST);
TestDone();
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
if (tc_tdm_output_is_hwc_enable(outputs[o]))
dst_layer = NULL;
else
FindLayer(o, formats[f], &dst_pos);
- ASSERT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
+ EXPECT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true);
- ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE);
for (int b = 0; b < 3; b++)
- ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE);
tdm_capture_destroy(capture);
capture = NULL;
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
if (tc_tdm_output_is_hwc_enable(outputs[o]))
dst_layer = NULL;
else
FindLayer(o, formats[f], &dst_pos);
- ASSERT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
+ EXPECT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true);
- ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE);
for (int b = 0; b < 3; b++)
- ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
tdm_capture_destroy(capture);
capture = NULL;
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
for (int f = 0; f < format_count; f++) {
int half_size = ((mode->hdisplay <= mode->vdisplay) ? mode->hdisplay : mode->vdisplay) / 2;
}
}
- ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f],
+ EXPECT_EQ(TestPrepare(o, half_size, half_size, formats[f],
TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true);
- ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, &done), TDM_ERROR_NONE);
retry:
for (int b = 0; b < 3; b++) {
done = false;
- ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
#if 0
char temp[256];
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
for (int f = 0; f < format_count; f++) {
int half_size = ((mode->hdisplay <= mode->vdisplay) ? mode->hdisplay : mode->vdisplay) / 2;
}
}
- ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f],
+ EXPECT_EQ(TestPrepare(o, half_size, half_size, formats[f],
TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, true), true);
- ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, &done), TDM_ERROR_NONE);
retry:
for (int b = 0; b < 3; b++) {
done = false;
- ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
#if 0
char temp[256];
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
for (int f = 0; f < format_count; f++) {
int half_size = ((mode->hdisplay <= mode->vdisplay) ? mode->hdisplay : mode->vdisplay) / 2;
}
}
- ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f],
+ EXPECT_EQ(TestPrepare(o, half_size, half_size, formats[f],
TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true);
done = 0;
- ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb2, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb2, &done), TDM_ERROR_NONE);
retry:
for (int b = 0; b < 3; b++)
- ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
while (done != 3)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
for (int b = 0; b < 3; b++) {
#if 0
tdm_buffer_remove_release_handler(buffer, _tc_tdm_backend_capture_buffer_release_cb, backend_capture);
- ASSERT_EQ(tdm_capture_attach(backend_capture->capture, buffer), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_capture_commit(backend_capture->capture), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_attach(backend_capture->capture, buffer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_commit(backend_capture->capture), TDM_ERROR_NONE);
}
static void
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
for (int f = 0; f < format_count; f++) {
int half_size = ((mode->hdisplay <= mode->vdisplay) ? mode->hdisplay : mode->vdisplay) / 2;
}
}
- ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f],
+ EXPECT_EQ(TestPrepare(o, half_size, half_size, formats[f],
TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_STREAM, -1, false), true);
- ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_stream_done_cb, (void*)this), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_stream_done_cb, (void*)this), TDM_ERROR_NONE);
for (int b = 0; b < 3; b++)
- ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE);
retry:
stream_exit = false;
stream_count = 30;
- ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
while (!stream_exit)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
TDM_UT_ASK_YNR("* Successed to capture a output to a '%c%c%c%c' buffer as letterbox size and show? (output: %d, layer: %d)",
FOURCC_STR(formats[f]), pipe, dst_layer_index);
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
for (int f = 0; f < format_count; f++) {
int half_size = ((mode->hdisplay <= mode->vdisplay) ? mode->hdisplay : mode->vdisplay) / 2;
}
}
- ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f],
+ EXPECT_EQ(TestPrepare(o, half_size, half_size, formats[f],
TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_STREAM, -1, true), true);
- ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_stream_done_cb, (void*)this), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_stream_done_cb, (void*)this), TDM_ERROR_NONE);
for (int b = 0; b < 3; b++)
- ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE);
retry:
stream_exit = false;
stream_count = 30;
- ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
while (!stream_exit)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
TDM_UT_ASK_YNR("* Successed to capture a output to a '%c%c%c%c' buffer as full size and show? (output: %d, layer: %d)",
FOURCC_STR(formats[f]), pipe, dst_layer_index);
TDMBackendEnv::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);
- ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
- ASSERT_GE(output_count, 0);
+ EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
+ EXPECT_GE(output_count, 0);
if (output_count > 0) {
outputs = (tdm_output**)calloc(output_count, sizeof(tdm_output*));
- ASSERT_NE(outputs, NULL);
+ EXPECT_NE(outputs, NULL);
for (int o = 0; o < output_count; o++) {
tdm_error ret;
tdm_output *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);
outputs[o] = output;
}
}
if (tc_tdm_output_is_hwc_enable(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
- ASSERT_GT(count, 0);
+ EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
+ EXPECT_GT(count, 0);
layer_count += count;
layers = (tdm_layer**)realloc(layers, layer_count * sizeof(tdm_layer*));
- ASSERT_NE(layers, NULL);
+ EXPECT_NE(layers, NULL);
for (int l = 0; l < count; l++) {
tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret);
- ASSERT_NE(layer, NULL);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(layer, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
layers[old_layer_count + l] = layer;
}
}
DestroyBuffers();
- ASSERT_EQ(tbm_bufmgr_debug_get_ref_count(), 0);
+ EXPECT_EQ(tbm_bufmgr_debug_get_ref_count(), 0);
TDMBackendEnv::TearDown();
}
tdm_error ret;
int output_count = 0;
- ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
TDM_UT_ASSERT_TRUE(output_count > 0, "output count(%d) should be greater than 0. Check display_get_outputs().");
for (int o = 0; o < output_count; o++) {
tdm_output *output = tdm_display_get_output(dpy, o, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
TDM_UT_ASSERT_TRUE(output != NULL, "no output. (output: %d). Check display_get_outputs().", o);
}
}
tdm_error ret;
int output_count = 0;
- ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
for (int o = 0; o < output_count; o++) {
tdm_output *output = tdm_display_get_output(dpy, o, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
if (tc_tdm_output_is_hwc_enable(outputs[o]))
TDM_UT_SKIP_FLAG(0);
int layer_count = 0;
- ASSERT_EQ(tdm_output_get_layer_count(output, &layer_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_layer_count(output, &layer_count), TDM_ERROR_NONE);
TDM_UT_ASSERT_TRUE(layer_count > 0,
"layer count(%d) should be greater than 0. (output: %d). Check output_get_layers().",
layer_count, o);
tdm_error ret;
int output_count = 0;
- ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
for (int o = 0; o < output_count; o++) {
tdm_output *output = tdm_display_get_output(dpy, o, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
const tdm_prop *props = NULL;
int prop_count = 0;
- ASSERT_EQ(tdm_output_get_available_properties(output, &props, &prop_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_available_properties(output, &props, &prop_count), TDM_ERROR_NONE);
if (prop_count > 0)
TDM_UT_ASSERT_TRUE(props != NULL, "no props. (output: %d). Check output_get_capability(), tdm_caps_output.", o);
for (int p = 0; p < prop_count; p++) {
tdm_value value;
value.s32 = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_property(output, props[p].id, &value), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_property(output, props[p].id, &value), TDM_ERROR_NONE);
TDM_UT_ASSERT_TRUE(value.s32 != TDM_UT_INVALID_VALUE,
"Getting a prop failed. (output: %d, prop_id: %d). Check output_get_property().",
o, props[p].id);
tdm_error ret;
int output_count = 0;
- ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
for (int o = 0; o < output_count; o++) {
tdm_output *output = tdm_display_get_output(dpy, o, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
if (tc_tdm_output_is_hwc_enable(outputs[o]))
TDM_UT_SKIP_FLAG(0);
int layer_count = 0;
- ASSERT_EQ(tdm_output_get_layer_count(output, &layer_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_layer_count(output, &layer_count), TDM_ERROR_NONE);
for (int l = 0; l < layer_count; l++) {
tdm_layer *layer = tdm_output_get_layer(output, l, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
const tdm_prop *props = NULL;
int prop_count = 0;
- ASSERT_EQ(tdm_layer_get_available_properties(layer, &props, &prop_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_get_available_properties(layer, &props, &prop_count), TDM_ERROR_NONE);
if (prop_count > 0)
TDM_UT_ASSERT_TRUE(props != NULL, "no props. (output: %d, layer: %d). Check output_get_capability(), tdm_caps_output.", o, l);
for (int p = 0; p < prop_count; p++) {
tdm_value value;
value.s32 = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_property(layer, props[p].id, &value), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_get_property(layer, props[p].id, &value), TDM_ERROR_NONE);
TDM_UT_ASSERT_TRUE(value.s32 != TDM_UT_INVALID_VALUE,
"Getting a prop failed. (output: %d, layer: %d, prop_id: %d). Check output_get_property().",
o, l, props[p].id);
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
TDM_UT_ASSERT_TRUE(count > 0, "mode's count should be greater than 0. Check output_get_capability(), tdm_caps_output.");
TDM_UT_ASSERT_TRUE(modes != NULL, "mode's count should be greater than 0. Check output_get_capability(), tdm_caps_output.");
}
if (!set_mode && best)
set_mode = best;
- ASSERT_NE(set_mode, NULL);
+ EXPECT_NE(set_mode, NULL);
- ASSERT_EQ(tdm_output_set_mode(outputs[o], set_mode), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_mode(outputs[o], &got_mode), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_mode(outputs[o], set_mode), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(outputs[o], &got_mode), TDM_ERROR_NONE);
TDM_UT_ASSERT_TRUE(set_mode == got_mode, "The mode which is set and got are different. Check output_set_mode(), output_get_mode()");
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
- ASSERT_GT(count, 0);
- ASSERT_NE(modes, NULL);
+ EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
+ EXPECT_GT(count, 0);
+ EXPECT_NE(modes, NULL);
for (int i = 0; i < count; i++) {
if (!best)
if (!set_mode && best)
set_mode = best;
- ASSERT_NE(set_mode, NULL);
- ASSERT_EQ(tdm_output_set_mode(outputs[o], set_mode), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_mode(outputs[o], &got_mode), TDM_ERROR_NONE);
- ASSERT_EQ(set_mode, got_mode);
+ EXPECT_NE(set_mode, NULL);
+ EXPECT_EQ(tdm_output_set_mode(outputs[o], set_mode), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(outputs[o], &got_mode), TDM_ERROR_NONE);
+ EXPECT_EQ(set_mode, got_mode);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], set_dpms), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_dpms(outputs[o], &got_dpms), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], set_dpms), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_dpms(outputs[o], &got_dpms), TDM_ERROR_NONE);
TDM_UT_ASSERT_TRUE(set_dpms == got_dpms, "The dpms value which is set and got are different. Check output_set_dpms(), output_get_dpms()");
}
}
if (tc_tdm_output_is_hwc_enable(outputs[o]))
TDM_UT_SKIP_FLAG(0);
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
retry:
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
TDM_UT_ASK_YNR("* Successed to display a frame to a primary layer? (output: %d)", o);
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
}
}
if (tc_tdm_output_is_hwc_enable(outputs[o]))
TDM_UT_SKIP_FLAG(0);
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
retry:
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 3, true), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 3, true), true);
/* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
usleep(40000); /* 40 ms */
next_buffer++;
if (next_buffer == 3)
TDM_UT_ASK_YNR("* Successed to display many frames to a primary layer? (output: %d)", o);
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
}
}
if (tc_tdm_output_is_hwc_enable(outputs[o]))
TDM_UT_SKIP_FLAG(0);
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
retry:
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
bool done = false;
TDM_UT_ASK_YNR("* Successed to display a frame to a primary layer? (output: %d)", o);
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
}
}
if (tc_tdm_output_is_hwc_enable(outputs[o]))
TDM_UT_SKIP_FLAG(0);
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, false), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, false), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
usleep(40000); /* 40 ms */
retry:
if (tdm_layer_get_output(layers[l], &ret) != outputs[o])
continue;
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[0]), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[0]), true);
DestroyBuffers();
}
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
TDM_UT_ASK_YNR("* Successed to display frames to all overlay layers? (output: %d)", o);
for (int l = 0; l < layer_count; l++)
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
}
}
if (tc_tdm_output_is_hwc_enable(outputs[o]))
TDM_UT_SKIP_FLAG(0);
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, false), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, false), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
usleep(40000); /* 40 ms */
for (int l = 0; l < layer_count; l++) {
if (tdm_layer_get_output(layers[l], &ret) != outputs[o])
continue;
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
retry:
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
/* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
usleep(40000); /* 40 ms */
next_buffer++;
if (next_buffer == 3)
TDM_UT_ASK_YNR("* Successed to display many frames to a layer? (output: %d, layer: %d)", o, l);
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
usleep(40000); /* 40 ms */
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
}
/* start from 1 */
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
}
/* start from 1 */
done = false;
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done), TDM_ERROR_NONE);
while (!done)
- 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 */
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
}
/* start from 1 */
interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done3), TDM_ERROR_NONE);
start = tdm_helper_get_time();
while (!done1 || !done2 || !done3)
- 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 */
int max_w = 0;
int max_h = 0;
int preferred_align = 0;
- ASSERT_EQ(tdm_display_get_pp_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
- ASSERT_NE(min_w, 0);
- ASSERT_NE(min_h, 0);
- ASSERT_NE(max_w, 0);
- ASSERT_NE(max_h, 0);
- ASSERT_NE(preferred_align, 0);
+ EXPECT_EQ(tdm_display_get_pp_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
+ EXPECT_NE(min_w, 0);
+ EXPECT_NE(min_h, 0);
+ EXPECT_NE(max_w, 0);
+ EXPECT_NE(max_h, 0);
+ EXPECT_NE(preferred_align, 0);
}
TEST_P(TDMBackendBasic, VerifyPPAvaiableFormats)
tdm_error ret;
unsigned int has_capability = 0;
- ASSERT_EQ(tdm_output_has_capture_capability(outputs[o], &has_capability), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_has_capture_capability(outputs[o], &has_capability), TDM_ERROR_NONE);
if (!has_capability) {
TDM_UT_INFO("Capture not supported. (output: %d)", o);
continue;
int max_w = 0;
int max_h = 0;
int preferred_align = 0;
- ASSERT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
- ASSERT_NE(min_w, 0);
- ASSERT_NE(min_h, 0);
- ASSERT_NE(max_w, 0);
- ASSERT_NE(max_h, 0);
- ASSERT_NE(preferred_align, 0);
+ EXPECT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
+ EXPECT_NE(min_w, 0);
+ EXPECT_NE(min_h, 0);
+ EXPECT_NE(max_w, 0);
+ EXPECT_NE(max_h, 0);
+ EXPECT_NE(preferred_align, 0);
}
TEST_P(TDMBackendBasic, VerifyCaptureAvaiableFormats)
TDM_UT_SKIP_FLAG(0);
layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
- ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
for (int f = 0; f < format_count; f++) {
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
- ASSERT_NE(mode, NULL);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
+ EXPECT_NE(mode, NULL);
retry:
TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
- ASSERT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ EXPECT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
/* set buffer & commit for 60 times */
for (int t = 0; t < 60; t++) {
tbm_surface_h displaying_buffer;
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
done = false;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
next_buffer++;
if (next_buffer == 3)
next_buffer = 0;
TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat)
{
- ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
+ EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
if (output_count > 0) {
if (tc_tdm_output_is_hwc_enable(outputs[0])) {
- ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
TDM_UT_SKIP_FLAG(0);
}
}
layer = layers[l];
output = tdm_layer_get_output(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
if (!tc_tdm_output_is_connected(output))
continue;
if (tc_tdm_layer_is_cursor_layer(layer))
continue;
- ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
- ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
- ASSERT_NE(mode, NULL);
+ EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
+ EXPECT_NE(mode, NULL);
- ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
for (int f = 0; f < format_count; f++) {
retry:
TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
- ASSERT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ EXPECT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
/* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
tbm_surface_h displaying_buffer;
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
done = false;
- ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
next_buffer++;
if (next_buffer == 3)
next_buffer = 0;
DestroyBuffers();
}
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
}
}
TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize)
{
- ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
+ EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
if (output_count > 0) {
if (tc_tdm_output_is_hwc_enable(outputs[0])) {
- ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
TDM_UT_SKIP_FLAG(0);
}
}
layer = layers[l];
output = tdm_layer_get_output(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
if (!tc_tdm_output_is_connected(output))
continue;
if (tc_tdm_layer_is_cursor_layer(layer))
continue;
- ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
- ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
- ASSERT_NE(mode, NULL);
+ EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
+ EXPECT_NE(mode, NULL);
- ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
for (int f = 0; f < format_count; f++) {
int diffw = mode->hdisplay / (format_count + 2);
int h = mode->vdisplay - diffh * (f + 1);
retry:
TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
- ASSERT_EQ(tc_tdm_buffer_create(w, h, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ EXPECT_EQ(tc_tdm_buffer_create(w, h, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
/* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
tbm_surface_h displaying_buffer;
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
done = false;
- ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
next_buffer++;
if (next_buffer == 3)
next_buffer = 0;
FOURCC_STR(formats[f]), w, h, pipe, l);
}
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
}
}
TEST_P(TDMBackendDisplay, VerifyOverlayLayerScale)
{
- ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
+ EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
if (output_count > 0) {
if (tc_tdm_output_is_hwc_enable(outputs[0])) {
- ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
TDM_UT_SKIP_FLAG(0);
}
}
layer = layers[l];
output = tdm_layer_get_output(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
if (!tc_tdm_output_is_connected(output))
continue;
continue;
}
- ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
- ASSERT_NE(mode, NULL);
+ EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
+ EXPECT_NE(mode, NULL);
- ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
for (int f = 0; f < format_count; f++) {
retry:
TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
- ASSERT_EQ(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ EXPECT_EQ(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
tdm_info_layer info;
memset(&info, 0, sizeof info);
info.dst_pos.w = mode->hdisplay;
info.dst_pos.h = mode->vdisplay;
info.transform = TDM_TRANSFORM_NORMAL;
- ASSERT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
/* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
tbm_surface_h displaying_buffer;
- ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
done = false;
- ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
next_buffer++;
if (next_buffer == 3)
next_buffer = 0;
FOURCC_STR(formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, pipe, l);
}
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
}
}
TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition)
{
- ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
+ EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
if (output_count > 0) {
if (tc_tdm_output_is_hwc_enable(outputs[0])) {
- ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
TDM_UT_SKIP_FLAG(0);
}
}
layer = layers[l];
output = tdm_layer_get_output(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
if (!tc_tdm_output_is_connected(output))
continue;
if (tc_tdm_layer_is_cursor_layer(layer))
continue;
- ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
- ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
- ASSERT_NE(mode, NULL);
+ EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
+ EXPECT_NE(mode, NULL);
- ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
for (int f = 0; f < format_count; f++) {
retry:
TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
- ASSERT_EQ(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ EXPECT_EQ(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
/* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
info.dst_pos.w = TDM_UT_BUFFER_SIZE;
info.dst_pos.h = TDM_UT_BUFFER_SIZE;
info.transform = TDM_TRANSFORM_NORMAL;
- ASSERT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
done = false;
- ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
next_buffer++;
if (next_buffer == 3)
next_buffer = 0;
FOURCC_STR(formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, pipe, l);
}
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
}
}
TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop)
{
- ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
+ EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
if (output_count > 0) {
if (tc_tdm_output_is_hwc_enable(outputs[0])) {
- ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
TDM_UT_SKIP_FLAG(0);
}
}
layer = layers[l];
output = tdm_layer_get_output(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
if (!tc_tdm_output_is_connected(output))
continue;
TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
- ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
- ASSERT_NE(mode, NULL);
+ EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
+ EXPECT_NE(mode, NULL);
- ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
for (int f = 0; f < format_count; f++) {
retry:
TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
- ASSERT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ EXPECT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
tdm_info_layer info;
memset(&info, 0, sizeof info);
info.dst_pos.w = info.src_config.pos.w;
info.dst_pos.h = info.src_config.pos.h;
info.transform = TDM_TRANSFORM_NORMAL;
- ASSERT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
/* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
tbm_surface_h displaying_buffer;
- ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
done = false;
- ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
next_buffer++;
if (next_buffer == 3)
next_buffer = 0;
FOURCC_STR(formats[f]), pipe, l);
}
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
}
}
/* should be debugged int emulator kernel */
TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOnToOff)
{
- ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
+ EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
for (int o = 0; o < output_count; o++) {
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
}
}
/* should be debugged int emulator kernel */
TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOffToOn)
{
- ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
+ EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
for (int o = 0; o < output_count; o++) {
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
}
}
if (tc_tdm_output_is_hwc_enable(outputs[o]))
TDM_UT_SKIP_FLAG(0);
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
if (tc_tdm_output_is_hwc_enable(outputs[o])) {
- ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
TDM_UT_SKIP_FLAG(0);
}
tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
}
}
TEST_P(TDMBackendDisplay, VerifyLayerGetInfo)
{
- ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
+ EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
for (int o = 0; o < output_count; o++) {
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
if (tc_tdm_output_is_hwc_enable(outputs[o])) {
- ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
TDM_UT_SKIP_FLAG(0);
}
tdm_error ret;
tdm_info_layer info, temp;
tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- ASSERT_NE(displaying_buffer, NULL);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_EQ(tc_tdm_layer_fill_info(layer, displaying_buffer, NULL, &info), true);
- ASSERT_EQ(tdm_layer_get_info(layer, &temp), TDM_ERROR_NONE);
- ASSERT_EQ(memcmp(&info, &temp, sizeof info), 0);
+ EXPECT_NE(displaying_buffer, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_fill_info(layer, displaying_buffer, NULL, &info), true);
+ EXPECT_EQ(tdm_layer_get_info(layer, &temp), TDM_ERROR_NONE);
+ EXPECT_EQ(memcmp(&info, &temp, sizeof info), 0);
}
}
if (!tc_tdm_display_has_pp_capability(dpy))
return;
- ASSERT_EQ(tdm_display_get_pp_capabilities(dpy, &capabilities), TDM_ERROR_NONE);
- ASSERT_GT(capabilities, 0);
- ASSERT_EQ(tdm_display_get_pp_available_formats(dpy, &formats, &format_count), TDM_ERROR_NONE);
- ASSERT_NE(formats, NULL);
- ASSERT_GT(format_count, 0);
- ASSERT_EQ(tdm_display_get_pp_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
- ASSERT_TRUE(min_w == -1 || min_w > 0);
- ASSERT_TRUE(min_h == -1 || min_h > 0);
- ASSERT_TRUE(max_w == -1 || max_w > 0);
- ASSERT_TRUE(max_h == -1 || max_h > 0);
- ASSERT_TRUE(preferred_align == -1 || preferred_align > 0);
- ASSERT_EQ(tdm_display_get_pp_preferred_align_vertical(dpy, &preferred_align_vertical), TDM_ERROR_NONE);
- ASSERT_TRUE(preferred_align_vertical == -1 || preferred_align_vertical > 0);
+ EXPECT_EQ(tdm_display_get_pp_capabilities(dpy, &capabilities), TDM_ERROR_NONE);
+ EXPECT_GT(capabilities, 0);
+ EXPECT_EQ(tdm_display_get_pp_available_formats(dpy, &formats, &format_count), TDM_ERROR_NONE);
+ EXPECT_NE(formats, NULL);
+ EXPECT_GT(format_count, 0);
+ EXPECT_EQ(tdm_display_get_pp_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
+ EXPECT_TRUE(min_w == -1 || min_w > 0);
+ EXPECT_TRUE(min_h == -1 || min_h > 0);
+ EXPECT_TRUE(max_w == -1 || max_w > 0);
+ EXPECT_TRUE(max_h == -1 || max_h > 0);
+ EXPECT_TRUE(preferred_align == -1 || preferred_align > 0);
+ EXPECT_EQ(tdm_display_get_pp_preferred_align_vertical(dpy, &preferred_align_vertical), TDM_ERROR_NONE);
+ EXPECT_TRUE(preferred_align_vertical == -1 || preferred_align_vertical > 0);
for (int o = 0; o < output_count; o++) {
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
output = outputs[o];
- ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
- ASSERT_EQ(tc_tdm_output_prepare(dpy, output, false), true);
- ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
- ASSERT_NE(mode, NULL);
+ EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, output, false), true);
+ EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
+ EXPECT_NE(mode, NULL);
break;
}
}
tdm_pp_destroy(pp);
DestroyBuffers();
- ASSERT_EQ(tc_tdm_output_unset(dpy, output), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, output), true);
TDMBackendDisplay::TearDown();
}
void TDMBackendPP::ShowBuffer(int b)
{
- ASSERT_NE(output, NULL);
+ EXPECT_NE(output, NULL);
if (tc_tdm_output_is_hwc_enable(output))
TDM_UT_SKIP_FLAG(0);
- ASSERT_NE(dst_layer, NULL);
+ EXPECT_NE(dst_layer, NULL);
bool done = false;
- ASSERT_EQ(tc_tdm_layer_set_buffer(dst_layer, dstbuf[b]), true);
- ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_pp_output_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(dst_layer, dstbuf[b]), true);
+ EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_pp_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done) {
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
void TDMBackendPP::HideLayer(void)
{
- ASSERT_NE(output, NULL);
+ EXPECT_NE(output, NULL);
if (tc_tdm_output_is_hwc_enable(output))
TDM_UT_SKIP_FLAG(0);
- ASSERT_NE(dst_layer, NULL);
+ EXPECT_NE(dst_layer, NULL);
tdm_layer_unset_buffer(dst_layer);
tdm_output_commit(output, 0, NULL, NULL);
const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
if (tc_tdm_display_has_pp_capability(dpy))
- ASSERT_EQ(tdm_display_get_pp_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_display_get_pp_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER);
else
- ASSERT_EQ(tdm_display_get_pp_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE);
- ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_display_get_pp_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMBackendPP, PPDispalyGetAvaiableFormatsNullOther)
{
if (tc_tdm_display_has_pp_capability(dpy)) {
- ASSERT_EQ(PreparePP(), true);
- ASSERT_EQ(tdm_display_get_pp_available_formats(pp, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(PreparePP(), true);
+ EXPECT_EQ(tdm_display_get_pp_available_formats(pp, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
}
int max_h = TDM_UT_INVALID_VALUE;
int preferred_align = TDM_UT_INVALID_VALUE;
if (tc_tdm_display_has_pp_capability(dpy))
- ASSERT_EQ(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
else
- ASSERT_EQ(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(min_w, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(min_h, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(max_w, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(max_h, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMBackendPP, PPDispalyGetAvaiableSizeNullOther)
{
if (tc_tdm_display_has_pp_capability(dpy)) {
- ASSERT_EQ(PreparePP(), true);
- ASSERT_EQ(tdm_display_get_pp_available_size(dpy, NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(PreparePP(), true);
+ EXPECT_EQ(tdm_display_get_pp_available_size(dpy, NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
}
}
TEST_P(TDMBackendPP, PPDispalyGetPreferredAlignVerticalNullObject)
{
if (tc_tdm_display_has_pp_capability(dpy)) {
- ASSERT_EQ(PreparePP(), true);
- ASSERT_EQ(tdm_display_get_pp_preferred_align_vertical(NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(PreparePP(), true);
+ EXPECT_EQ(tdm_display_get_pp_preferred_align_vertical(NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
}
{
TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
- ASSERT_EQ(PreparePP(), true);
+ EXPECT_EQ(PreparePP(), true);
tdm_pp_destroy(pp);
pp = NULL;
}
tdm_info_pp info;
memset(&info, 0, sizeof info);
- ASSERT_EQ(tdm_pp_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_pp_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMBackendPP, PPSetInfoNullOther)
{
TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
- ASSERT_EQ(PreparePP(), true);
- ASSERT_EQ(tdm_pp_set_info(pp, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(PreparePP(), true);
+ EXPECT_EQ(tdm_pp_set_info(pp, NULL), TDM_ERROR_INVALID_PARAMETER);
}
static void
{
TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
- ASSERT_EQ(PreparePP(), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(PreparePP(), true);
+ EXPECT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, NULL), TDM_ERROR_NONE);
}
TEST_P(TDMBackendPP, PPSetDoneHandlerNullObject)
{
TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
- ASSERT_EQ(tdm_pp_set_done_handler(NULL, _tc_tdm_pp_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_pp_set_done_handler(NULL, _tc_tdm_pp_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMBackendPP, PPSetDoneHandlerNullOther)
{
TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
- ASSERT_EQ(PreparePP(), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(PreparePP(), true);
+ EXPECT_EQ(tdm_pp_set_done_handler(pp, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMBackendPP, PPAttach)
{
TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
- ASSERT_EQ(PreparePP(), true);
+ EXPECT_EQ(PreparePP(), true);
for (int f = 0; f < format_count; f++) {
- ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
+ EXPECT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
TDM_TRANSFORM_NORMAL), true);
for (int b = 0; b < 3; b++)
- ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE);
DestroyBuffers();
}
tbm_surface_h srcbuf = (tbm_surface_h)TDM_UT_BUFFER_SIZE;
tbm_surface_h dstbuf = (tbm_surface_h)TDM_UT_BUFFER_SIZE;
- ASSERT_EQ(tdm_pp_attach(NULL, srcbuf, dstbuf), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_pp_attach(NULL, srcbuf, dstbuf), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMBackendPP, PPAttachNullOther)
{
TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
- ASSERT_EQ(PreparePP(), true);
+ EXPECT_EQ(PreparePP(), true);
- ASSERT_EQ(tdm_pp_attach(pp, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_pp_attach(pp, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMBackendPP, PPCommit)
{
TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
- ASSERT_EQ(PreparePP(), true);
+ EXPECT_EQ(PreparePP(), true);
- ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
}
TEST_P(TDMBackendPP, PPCommitNullOBject)
{
TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
- ASSERT_EQ(tdm_pp_commit(NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_pp_commit(NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMBackendPP, PPConvertUnderlay)
FindLayerUnderPrimary();
if (!tc_tdm_output_is_hwc_enable(output))
- ASSERT_NE(dst_layer, NULL);
+ EXPECT_NE(dst_layer, NULL);
for (int f = 0; f < dst_format_count; f++) {
bool done;
TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(dst_formats[f]));
- ASSERT_EQ(PreparePP(), true);
+ EXPECT_EQ(PreparePP(), true);
- ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f],
+ EXPECT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f],
TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f],
TDM_TRANSFORM_NORMAL), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
retry:
for (int b = 0; b < 3; b++) {
done = false;
- ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
#if 0
char temp[256];
TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(dst_formats[f]));
- ASSERT_EQ(PreparePP(), true);
+ EXPECT_EQ(PreparePP(), true);
- ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f],
+ EXPECT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f],
TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f],
TDM_TRANSFORM_NORMAL), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
retry:
for (int b = 0; b < 3; b++) {
done = false;
- ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
#if 0
char temp[256];
FindLayerUnderPrimary();
if (!tc_tdm_output_is_hwc_enable(output))
- ASSERT_NE(dst_layer, NULL);
+ EXPECT_NE(dst_layer, NULL);
for (int f = 0; f < dst_format_count; f++) {
bool done;
TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(dst_formats[f]));
- ASSERT_EQ(PreparePP(), true);
+ EXPECT_EQ(PreparePP(), true);
- ASSERT_EQ(PrepareBuffers(640, 480, dst_formats[f],
+ EXPECT_EQ(PrepareBuffers(640, 480, dst_formats[f],
mode->hdisplay, mode->vdisplay, dst_formats[f],
TDM_TRANSFORM_NORMAL), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
retry:
for (int b = 0; b < 3; b++) {
done = false;
- ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
#if 0
char temp[256];
FindLayerUnderPrimary();
if (!tc_tdm_output_is_hwc_enable(output))
- ASSERT_NE(dst_layer, NULL);
+ EXPECT_NE(dst_layer, NULL);
for (int f = 0; f < dst_format_count; f++) {
for (int t = (int)TDM_TRANSFORM_90; t <= (int)TDM_TRANSFORM_FLIPPED_270; t++) {
TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(dst_formats[f]));
- ASSERT_EQ(PreparePP(), true);
+ EXPECT_EQ(PreparePP(), true);
- ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f],
+ EXPECT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f],
TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f],
(tdm_transform)t), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
retry:
for (int b = 0; b < 3; b++) {
done = false;
- ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
#if 0
char temp[256];
FindLayerUnderPrimary();
if (!tc_tdm_output_is_hwc_enable(output))
- ASSERT_NE(dst_layer, NULL);
+ EXPECT_NE(dst_layer, NULL);
for (int df = 0; df < dst_format_count; df++) {
for (int sf = 0; sf < format_count; sf++) {
TDM_UT_INFO("* testing for format(%c%c%c%c) -> format(%c%c%c%c)",
FOURCC_STR(formats[sf]), FOURCC_STR(dst_formats[df]));
- ASSERT_EQ(PreparePP(), true);
+ EXPECT_EQ(PreparePP(), true);
- ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, formats[sf],
+ EXPECT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, formats[sf],
TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[df],
TDM_TRANSFORM_NORMAL), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
retry:
for (int b = 0; b < 3; b++) {
done = false;
- ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
#if 0
char temp[256];
{
TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
- ASSERT_EQ(PreparePP(), true);
+ EXPECT_EQ(PreparePP(), true);
int done = 0;
int f = 0;
char temp[256];
snprintf(temp, sizeof temp, "%c%c%c%c", FOURCC_STR(formats[f]));
- ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
+ EXPECT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
TDM_TRANSFORM_NORMAL), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb2, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb2, &done), TDM_ERROR_NONE);
for (int b = 0; b < 3; b++)
- ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
while (done != 3)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
for (int b = 0; b < 3; b++)
ShowBuffer(b);
{
TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
- ASSERT_EQ(PreparePP(), true);
+ EXPECT_EQ(PreparePP(), true);
int f = 0;
- ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
+ EXPECT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
TDM_TRANSFORM_NORMAL), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb2, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb2, NULL), TDM_ERROR_NONE);
for (int b = 0; b < 3; b++)
- ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE);
tdm_pp_destroy(pp);
pp = NULL;
{
TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
- ASSERT_EQ(PreparePP(), true);
+ EXPECT_EQ(PreparePP(), true);
int f = 0;
- ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
+ EXPECT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
TDM_TRANSFORM_NORMAL), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb2, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb2, NULL), TDM_ERROR_NONE);
for (int b = 0; b < 3; b++)
- ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
tdm_pp_destroy(pp);
pp = NULL;
TDMDisplay::SetUp();
buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
- ASSERT_NE(buffer, NULL);
+ EXPECT_NE(buffer, NULL);
}
void TDMBuffer::TearDown(void)
TEST_P(TDMBuffer, BufferRefBackend)
{
- ASSERT_EQ(tdm_buffer_ref_backend(buffer), buffer);
+ EXPECT_EQ(tdm_buffer_ref_backend(buffer), buffer);
tdm_buffer_unref_backend(buffer);
}
TEST_P(TDMBuffer, BufferRefBackendNullOBject)
{
- ASSERT_EQ(tdm_buffer_ref_backend(NULL), NULL);
+ EXPECT_EQ(tdm_buffer_ref_backend(NULL), NULL);
}
TEST_P(TDMBuffer, BufferUnrefBackend)
TEST_P(TDMBuffer, BufferAddDestroyHandler)
{
bool done = false;
- ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE);
tbm_surface_destroy(buffer);
buffer = NULL;
- ASSERT_EQ(done, true);
+ EXPECT_EQ(done, true);
}
TEST_P(TDMBuffer, BufferAddDestroyHandlerTwice)
{
- ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, NULL), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, NULL), TDM_ERROR_BAD_REQUEST);
}
TEST_P(TDMBuffer, BufferAddDestroyHandlerNullObject)
{
- ASSERT_EQ(tdm_buffer_add_destroy_handler(NULL, _tc_tdm_buffer_destroy_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_buffer_add_destroy_handler(NULL, _tc_tdm_buffer_destroy_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMBuffer, BufferAddDestroyHandlerNullOther)
{
- ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_buffer_add_destroy_handler(buffer, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMBuffer, BufferRemoveDestroyHandler)
{
bool done = false;
- ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE);
tdm_buffer_remove_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, &done);
tbm_surface_destroy(buffer);
buffer = NULL;
- ASSERT_EQ(done, false);
+ EXPECT_EQ(done, false);
}
TEST_P(TDMBuffer, BufferRemoveDestroyHandlerDifferentData)
{
bool done = false;
- ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE);
tdm_buffer_remove_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, NULL);
tbm_surface_destroy(buffer);
buffer = NULL;
- ASSERT_EQ(done, true);
+ EXPECT_EQ(done, true);
}
TEST_P(TDMBuffer, BufferRemoveDestroyHandlerNullObject)
TEST_P(TDMBuffer, BufferAddReleaseHandler)
{
bool done = false;
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE);
tdm_buffer_ref_backend(buffer);
- ASSERT_EQ(done, false);
+ EXPECT_EQ(done, false);
tdm_buffer_unref_backend(buffer);
- ASSERT_EQ(done, true);
+ EXPECT_EQ(done, true);
}
TEST_P(TDMBuffer, BufferAddReleaseHandlerTwice)
{
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, NULL), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, NULL), TDM_ERROR_BAD_REQUEST);
}
TEST_P(TDMBuffer, BufferAddReleaseHandlerNullObject)
{
bool done = false;
- ASSERT_EQ(tdm_buffer_add_release_handler(NULL, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(done, false);
+ EXPECT_EQ(tdm_buffer_add_release_handler(NULL, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(done, false);
}
TEST_P(TDMBuffer, BufferAddReleaseHandlerNullOther)
{
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_buffer_add_release_handler(buffer, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMBuffer, BufferRemoveReleaseHandler)
{
bool done = false;
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE);
tdm_buffer_ref_backend(buffer);
- ASSERT_EQ(done, false);
+ EXPECT_EQ(done, false);
tdm_buffer_remove_release_handler(buffer, _tc_tdm_buffer_release_cb, &done);
tdm_buffer_unref_backend(buffer);
- ASSERT_EQ(done, false);
+ EXPECT_EQ(done, false);
}
TEST_P(TDMBuffer, BufferRemoveReleaseHandlerDifferentData)
{
bool done = false;
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE);
tdm_buffer_ref_backend(buffer);
- ASSERT_EQ(done, false);
+ EXPECT_EQ(done, false);
tdm_buffer_remove_release_handler(buffer, _tc_tdm_buffer_release_cb, NULL);
tdm_buffer_unref_backend(buffer);
- ASSERT_EQ(done, true);
+ EXPECT_EQ(done, true);
}
static void
TEST_P(TDMBuffer, BufferRemoveReleaseHandlerInHandler)
{
bool done = false;
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE);
tdm_buffer_ref_backend(buffer);
- ASSERT_EQ(done, false);
+ EXPECT_EQ(done, false);
tdm_buffer_unref_backend(buffer);
- ASSERT_EQ(done, true);
+ EXPECT_EQ(done, true);
done = false;
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE);
tdm_buffer_ref_backend(buffer);
- ASSERT_EQ(done, false);
+ EXPECT_EQ(done, false);
tdm_buffer_unref_backend(buffer);
- ASSERT_EQ(done, true);
+ EXPECT_EQ(done, true);
done = false;
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE);
tdm_buffer_ref_backend(buffer);
- ASSERT_EQ(done, false);
+ EXPECT_EQ(done, false);
tdm_buffer_unref_backend(buffer);
- ASSERT_EQ(done, true);
+ EXPECT_EQ(done, true);
}
TEST_P(TDMBuffer, BufferRemoveReleaseHandlerNullObject)
{
bool done = false;
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE);
tdm_buffer_ref_backend(buffer);
- ASSERT_EQ(done, false);
+ EXPECT_EQ(done, false);
tdm_buffer_remove_release_handler(NULL, _tc_tdm_buffer_release_cb, &done);
tdm_buffer_unref_backend(buffer);
- ASSERT_EQ(done, true);
+ EXPECT_EQ(done, true);
}
TEST_P(TDMBuffer, BufferRemoveReleaseHandlerNullOther)
return;
server_pid = _tc_tdm_client_server_fork(pipe_parent, pipe_child);
- ASSERT_GT(server_pid, 0);
+ EXPECT_GT(server_pid, 0);
}
void TDMClient::ServerKill(void)
tdm_error ret;
client = tdm_client_create(&ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(client, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(client, NULL);
}
TEST_P(TDMClient, ClientCreateNullOther)
{
client = tdm_client_create(NULL);
- ASSERT_NE(client, NULL);
+ EXPECT_NE(client, NULL);
}
TEST_P(TDMClient, ClientDestroy)
tdm_error ret;
client = tdm_client_create(&ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(client, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(client, NULL);
tdm_client_destroy(client);
client = NULL;
{
int fd = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareClient(), true);
- ASSERT_EQ(tdm_client_get_fd(client, &fd), TDM_ERROR_NONE);
- ASSERT_GE(fd, 0);
+ EXPECT_EQ(tdm_client_get_fd(client, &fd), TDM_ERROR_NONE);
+ EXPECT_GE(fd, 0);
}
TEST_P(TDMClient, ClientGetFdNullObject)
{
int fd = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_client_get_fd(NULL, &fd), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(fd, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_client_get_fd(NULL, &fd), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(fd, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMClient, ClientGetFdNullOther)
{
- ASSERT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareClient(), true);
- ASSERT_EQ(tdm_client_get_fd(client, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_client_get_fd(client, NULL), TDM_ERROR_INVALID_PARAMETER);
}
static void
{
bool done = false;
- ASSERT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareClient(), true);
- ASSERT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _tc_tdm_client_vblank_cb, &done), TDM_ERROR_NONE);
- ASSERT_EQ(done, false);
+ EXPECT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _tc_tdm_client_vblank_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(done, false);
while (!done)
- ASSERT_EQ(tdm_client_handle_events(client), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events(client), TDM_ERROR_NONE);
}
TEST_P(TDMClient, ClientHandleEventNullObject)
{
- ASSERT_EQ(tdm_client_handle_events(NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_client_handle_events(NULL), TDM_ERROR_INVALID_PARAMETER);
}
/* tdm_client_wait_vblank, deprecated */
{
bool done = false;
- ASSERT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareClient(), true);
- ASSERT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _tc_tdm_client_vblank_cb, &done), TDM_ERROR_NONE);
- ASSERT_EQ(done, false);
+ EXPECT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _tc_tdm_client_vblank_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(done, false);
while (!done)
- ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
}
/* tdm_client_get_output */
{
tdm_error ret;
- ASSERT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareClient(), true);
output = tdm_client_get_output(client, NULL, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(output, NULL);
}
TEST_P(TDMClient, ClientGetOutputPrimary)
{
tdm_error ret;
- ASSERT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareClient(), true);
output = tdm_client_get_output(client, (char*)"primary", &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(output, NULL);
}
TEST_P(TDMClient, ClientGetOutputDefault)
{
tdm_error ret;
- ASSERT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareClient(), true);
output = tdm_client_get_output(client, (char*)"default", &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(output, NULL);
}
TEST_P(TDMClient, ClientGetOutputInvalidName)
{
tdm_error ret;
- ASSERT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareClient(), true);
output = tdm_client_get_output(client, (char*)"invalid", &ret);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(output, NULL);
}
TEST_P(TDMClient, ClientGetOutputNullObject)
tdm_error ret;
output = tdm_client_get_output(NULL, NULL, &ret);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(output, NULL);
}
TEST_P(TDMClient, ClientGetOutputNullOther)
{
- ASSERT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareClient(), true);
output = tdm_client_get_output(client, NULL, NULL);
- ASSERT_NE(output, NULL);
+ EXPECT_NE(output, NULL);
}
static void
bool done = false;
tdm_output_dpms dpms;
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
- ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE);
- ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
+ EXPECT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
while (!done)
- ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
- ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF);
+ EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+ EXPECT_EQ(dpms, TDM_OUTPUT_DPMS_OFF);
- ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
+ EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
while (dpms != TDM_OUTPUT_DPMS_ON) {
- ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
}
}
TEST_P(TDMClient, ClientOutputAddChangeHandlerTwice)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
- ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_BAD_REQUEST);
}
TEST_P(TDMClient, ClientOutputAddChangeHandlerNullObject)
{
- ASSERT_EQ(tdm_client_output_add_change_handler(NULL, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_client_output_add_change_handler(NULL, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMClient, ClientOutputAddChangeHandlerNullOther)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
- ASSERT_EQ(tdm_client_output_add_change_handler(output, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_client_output_add_change_handler(output, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
/* tdm_client_output_remove_change_handler */
TEST_P(TDMClient, ClientOutputRemoveChangeHandler)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
- ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE);
tdm_client_output_remove_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL);
}
{
bool done = (bool)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
- ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE);
tdm_client_output_remove_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL);
}
{
tdm_output_dpms dpms = TDM_OUTPUT_DPMS_ON;
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
- ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb2, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
- ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb2, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
+ EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
while (dpms != TDM_OUTPUT_DPMS_OFF) {
- ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
}
- ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
+ EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
while (dpms != TDM_OUTPUT_DPMS_ON)
- ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
}
TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullObject)
TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullOther)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
tdm_client_output_remove_change_handler(output, NULL, NULL);
}
{
unsigned int refresh = 0;
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
- ASSERT_EQ(tdm_client_output_get_refresh_rate(output, &refresh), TDM_ERROR_NONE);
- ASSERT_GT(refresh, 0);
+ EXPECT_EQ(tdm_client_output_get_refresh_rate(output, &refresh), TDM_ERROR_NONE);
+ EXPECT_GT(refresh, 0);
}
TEST_P(TDMClient, ClientOutputGetRefreshRateNullObject)
{
unsigned int refresh = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_client_output_get_refresh_rate(NULL, &refresh), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(refresh, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_client_output_get_refresh_rate(NULL, &refresh), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(refresh, (unsigned int)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMClient, ClientOutputGetRefreshRateNullOther)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
- ASSERT_EQ(tdm_client_output_get_refresh_rate(output, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_client_output_get_refresh_rate(output, NULL), TDM_ERROR_INVALID_PARAMETER);
}
/* tdm_client_output_get_mode */
{
unsigned int width = 0, height = 0;
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
- ASSERT_EQ(tdm_client_output_get_mode(output, &width, &height), TDM_ERROR_NONE);
- ASSERT_GT(width, 0);
- ASSERT_GT(height, 0);
+ EXPECT_EQ(tdm_client_output_get_mode(output, &width, &height), TDM_ERROR_NONE);
+ EXPECT_GT(width, 0);
+ EXPECT_GT(height, 0);
}
TEST_P(TDMClient, ClientOutputGetModeNullObject)
unsigned int width = (unsigned int)TDM_UT_INVALID_VALUE;
unsigned int height = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_client_output_get_mode(NULL, &width, &height), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(width, (unsigned int)TDM_UT_INVALID_VALUE);
- ASSERT_EQ(height, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_client_output_get_mode(NULL, &width, &height), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(width, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(height, (unsigned int)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMClient, ClientOutputGetModeNullOther)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
- ASSERT_EQ(tdm_client_output_get_mode(output, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_client_output_get_mode(output, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
/* tdm_client_output_get_conn_status */
{
tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
- ASSERT_EQ(tdm_client_output_get_conn_status(output, &status), TDM_ERROR_NONE);
- ASSERT_NE(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_client_output_get_conn_status(output, &status), TDM_ERROR_NONE);
+ EXPECT_NE(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMClient, ClientOutputGetConnStatusNullObject)
{
tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_client_output_get_conn_status(NULL, &status), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_client_output_get_conn_status(NULL, &status), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMClient, ClientOutputGetConnStatusNullOther)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
- ASSERT_EQ(tdm_client_output_get_conn_status(output, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_client_output_get_conn_status(output, NULL), TDM_ERROR_INVALID_PARAMETER);
}
/* tdm_client_output_get_dpms */
{
tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
- ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
- ASSERT_NE(dpms, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+ EXPECT_NE(dpms, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMClient, ClientOutputGetDpmsNullObject)
{
tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_client_output_get_dpms(NULL, &dpms), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(dpms, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_client_output_get_dpms(NULL, &dpms), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(dpms, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMClient, ClientOutputGetDpmsNullOther)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
- ASSERT_EQ(tdm_client_output_get_dpms(output, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_client_output_get_dpms(output, NULL), TDM_ERROR_INVALID_PARAMETER);
}
/* tdm_client_output_create_vblank */
{
tdm_error ret;
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
vblank = tdm_client_output_create_vblank(output, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(vblank, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(vblank, NULL);
}
TEST_P(TDMClient, ClientOutputCreateVblankNullObject)
tdm_error ret;
vblank = tdm_client_output_create_vblank(NULL, &ret);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(vblank, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(vblank, NULL);
}
TEST_P(TDMClient, ClientOutputCreateVblankNullOther)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
vblank = tdm_client_output_create_vblank(output, NULL);
- ASSERT_NE(vblank, NULL);
+ EXPECT_NE(vblank, NULL);
}
/* tdm_client_vblank_destroy */
{
tdm_error ret;
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
vblank = tdm_client_output_create_vblank(output, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(vblank, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(vblank, NULL);
tdm_client_vblank_destroy(vblank);
vblank = NULL;
/* tdm_client_vblank_set_name */
TEST_P(TDMClient, ClientVblankSetName)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
- ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
}
TEST_P(TDMClient, ClientVblankSetNameTwice)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
- ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
}
TEST_P(TDMClient, ClientVblankSetNameNullObject)
{
- ASSERT_EQ(tdm_client_vblank_set_name(NULL, TDM_UT_VBLANK_NAME), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_client_vblank_set_name(NULL, TDM_UT_VBLANK_NAME), TDM_ERROR_INVALID_PARAMETER);
}
/* tdm_client_vblank_set_sync */
TEST_P(TDMClient, ClientVblankSetSync)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
- ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
}
TEST_P(TDMClient, ClientVblankSetSyncTwice)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
- ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
}
TEST_P(TDMClient, ClientVblankSetSyncNullObject)
{
- ASSERT_EQ(tdm_client_vblank_set_sync(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_client_vblank_set_sync(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
}
/* tdm_client_vblank_set_fps */
TEST_P(TDMClient, ClientVblankSetFps)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
- ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
}
TEST_P(TDMClient, ClientVblankSetFpsTwice)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
- ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
}
TEST_P(TDMClient, ClientVblankSetFpsNullObject)
{
- ASSERT_EQ(tdm_client_vblank_set_fps(NULL, 30), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_client_vblank_set_fps(NULL, 30), TDM_ERROR_INVALID_PARAMETER);
}
/* tdm_client_vblank_set_offset */
TEST_P(TDMClient, ClientVblankSetOffset)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
- ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
}
TEST_P(TDMClient, ClientVblankSetOffsetTwice)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
- ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
}
TEST_P(TDMClient, ClientVblankSetOffsetNullObject)
{
- ASSERT_EQ(tdm_client_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_client_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER);
}
/* tdm_client_vblank_set_enable_fake */
TEST_P(TDMClient, ClientVblankSetEnableFake)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
- ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
}
TEST_P(TDMClient, ClientVblankSetEnableFakeTwice)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
- ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
}
TEST_P(TDMClient, ClientVblankSetEnableFakeNullObject)
{
- ASSERT_EQ(tdm_client_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_client_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
}
static void
{
bool done;
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
done = false;
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
start = tdm_helper_get_time();
while (!done)
- ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
end = tdm_helper_get_time();
/* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
- ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
+ EXPECT_LT((end - start), (vrefresh_interval + vrefresh_interval));
}
TEST_P(TDMClient, ClientVblankWaitFewTime)
{
bool done1, done2, done3;
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done3), TDM_ERROR_NONE);
start = tdm_helper_get_time();
while (!done1 || !done2 || !done3)
- ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
end = tdm_helper_get_time();
/* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
- ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
+ EXPECT_LT((end - start), (vrefresh_interval + vrefresh_interval));
}
TEST_P(TDMClient, ClientVblankWaitInterval0)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 0, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_client_vblank_wait(vblank, 0, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMClient, ClientVblankWaitInterval)
{
bool done;
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
/* start from 1 */
for (int t = 1; t < 10; t++) {
done = false;
- ASSERT_EQ(tdm_client_vblank_wait(vblank, t, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_wait(vblank, t, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
start = tdm_helper_get_time();
while (!done)
- ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
end = tdm_helper_get_time();
/* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
- ASSERT_GT((end - start), (vrefresh_interval * (t - 1)));
- ASSERT_LT((end - start), (vrefresh_interval * t + vrefresh_interval));
+ EXPECT_GT((end - start), (vrefresh_interval * (t - 1)));
+ EXPECT_LT((end - start), (vrefresh_interval * t + vrefresh_interval));
}
}
TEST_P(TDMClient, ClientVblankWaitSeq)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
for (int t = 0; t < 10; t++) {
unsigned int cur_seq = 0, temp = 0;
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE);
while (cur_seq == 0)
- ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + 1, _tc_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + 1, _tc_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE);
while (temp == 0)
- ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
end = tdm_helper_get_time();
/* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
- ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
+ EXPECT_LT((end - start), (vrefresh_interval + vrefresh_interval));
}
}
TEST_P(TDMClient, ClientVblankWaitSeqInterval)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
/* start from 1 */
for (int t = 1; t < 10; t++) {
unsigned int cur_seq = 0, temp = 0;
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE);
while (cur_seq == 0)
- ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + t, _tc_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + t, _tc_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE);
while (temp == 0)
- ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
end = tdm_helper_get_time();
/* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
- ASSERT_GT((end - start), (vrefresh_interval * (t - 1)));
- ASSERT_LT((end - start), (vrefresh_interval * t + vrefresh_interval));
+ EXPECT_GT((end - start), (vrefresh_interval * (t - 1)));
+ EXPECT_LT((end - start), (vrefresh_interval * t + vrefresh_interval));
}
}
{
bool done;
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
- ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 100), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_set_offset(vblank, 100), TDM_ERROR_NONE);
done = false;
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
start = tdm_helper_get_time();
while (!done)
- ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
end = tdm_helper_get_time();
/* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
- ASSERT_GT((end - start), (0.1));
- ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval + 0.1));
+ EXPECT_GT((end - start), (0.1));
+ EXPECT_LT((end - start), (vrefresh_interval + vrefresh_interval + 0.1));
}
TEST_P(TDMClient, ClientVblankWaitSetFps)
double interval;
unsigned int fps = 10;
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
- ASSERT_EQ(tdm_client_vblank_set_fps(vblank, fps), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_set_fps(vblank, fps), TDM_ERROR_NONE);
interval = 1.0 / (double)fps;
done = false;
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
start = tdm_helper_get_time();
while (!done)
- ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
end = tdm_helper_get_time();
/* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
- ASSERT_GT((end - start), (interval - vrefresh_interval * 2));
- ASSERT_LT((end - start), (interval + vrefresh_interval));
+ EXPECT_GT((end - start), (interval - vrefresh_interval * 2));
+ EXPECT_LT((end - start), (interval + vrefresh_interval));
}
#if 0
unsigned int global_fps = 5;
double start, end, interval;
- ASSERT_EQ(TestPrepareOutput(), true);
- ASSERT_EQ(TestCreateVblanks3(), true);
- ASSERT_EQ(vblank_count, 3);
+ EXPECT_EQ(TestPrepareOutput(), true);
+ EXPECT_EQ(TestCreateVblanks3(), true);
+ EXPECT_EQ(vblank_count, 3);
- ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE);
- ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE);
+ EXPECT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
vrefresh_interval = 1.0 / (double)fps;
for (int v = 0; v < 3; v++)
- ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)), TDM_ERROR_NONE);
/* enable test */
tdm_vblank_enable_global_fps(1, global_fps);
for (int v = 0; v < 3; v++) {
cur_seq[v] = 0;
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
}
start = tdm_helper_get_time();
while (cur_seq[0] == 0)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
end = tdm_helper_get_time();
- ASSERT_NE(cur_seq[1], 0);
- ASSERT_NE(cur_seq[2], 0);
+ EXPECT_NE(cur_seq[1], 0);
+ EXPECT_NE(cur_seq[2], 0);
/* "+- vrefresh_interval" consider the delay of socket communication between kernel and platform */
- ASSERT_GT((end - start), (interval - vrefresh_interval));
- ASSERT_LT((end - start), (interval + vrefresh_interval));
+ EXPECT_GT((end - start), (interval - vrefresh_interval));
+ EXPECT_LT((end - start), (interval + vrefresh_interval));
/* disable test */
tdm_vblank_enable_global_fps(0, 0);
for (int v = 0; v < 3; v++) {
cur_seq[v] = 0;
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
}
while (cur_seq[0] == 0)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
- ASSERT_EQ(cur_seq[1], 0);
- ASSERT_EQ(cur_seq[2], 0);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(cur_seq[1], 0);
+ EXPECT_EQ(cur_seq[2], 0);
while (cur_seq[1] == 0)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
- ASSERT_EQ(cur_seq[2], 0);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(cur_seq[2], 0);
}
TEST_P(TDMVblank, VblankWaitIgnoreGlobalFps)
unsigned int global_fps = 5;
double start, end, interval;
- ASSERT_EQ(TestPrepareOutput(), true);
- ASSERT_EQ(TestCreateVblanks3(), true);
- ASSERT_EQ(vblank_count, 3);
+ EXPECT_EQ(TestPrepareOutput(), true);
+ EXPECT_EQ(TestCreateVblanks3(), true);
+ EXPECT_EQ(vblank_count, 3);
- ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE);
- ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE);
+ EXPECT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
interval = 1.0 / (double)fps;
/* 2nd vblank will ignore the global fps. */
- ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[1], 1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_vblank_ignore_global_fps(vblanks[1], 1), TDM_ERROR_NONE);
tdm_vblank_enable_global_fps(1, global_fps);
for (int v = 0; v < 3; v++) {
cur_seq[v] = 0;
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
}
start = tdm_helper_get_time();
while (cur_seq[1] == 0)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
end = tdm_helper_get_time();
- ASSERT_EQ(cur_seq[0], 0);
- ASSERT_EQ(cur_seq[2], 0);
+ EXPECT_EQ(cur_seq[0], 0);
+ EXPECT_EQ(cur_seq[2], 0);
/* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
- ASSERT_LT((end - start), (interval + interval));
+ EXPECT_LT((end - start), (interval + interval));
while (cur_seq[0] == 0)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
- ASSERT_NE(cur_seq[2], 0);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_NE(cur_seq[2], 0);
}
#endif
{
unsigned int cur_seq = 0;
- ASSERT_EQ(tdm_client_vblank_wait(NULL, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_client_vblank_wait(NULL, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMClient, ClientVblankWaitNullOther)
{
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMClient, ClientVblankWaitDpmsOff)
{
tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
- ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
+ EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
while (dpms != TDM_OUTPUT_DPMS_OFF)
- ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
- ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF);
+ EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+ EXPECT_EQ(dpms, TDM_OUTPUT_DPMS_OFF);
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_DPMS_OFF);
+ EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_DPMS_OFF);
- ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
+ EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
while (dpms != TDM_OUTPUT_DPMS_ON)
- ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
}
TEST_P(TDMClient, ClientVblankWaitSetEnableFakeDpmsOff)
tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
bool done;
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
- ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
+ EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
while (dpms != TDM_OUTPUT_DPMS_OFF)
- ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
done = false;
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
- ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
+ EXPECT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
while (dpms != TDM_OUTPUT_DPMS_ON)
- ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
}
/* tdm_client_vblank_wait */
bool done;
unsigned int waiting;
- ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(PrepareVblank(), true);
+ EXPECT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareOutput(), true);
+ EXPECT_EQ(PrepareVblank(), true);
done = false;
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
waiting = tdm_client_vblank_is_waiting(vblank);
- ASSERT_EQ(waiting, 1);
+ EXPECT_EQ(waiting, 1);
start = tdm_helper_get_time();
while (!done)
- ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
end = tdm_helper_get_time();
/* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
- ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
+ EXPECT_LT((end - start), (vrefresh_interval + vrefresh_interval));
waiting = tdm_client_vblank_is_waiting(vblank);
- ASSERT_EQ(waiting, 0);
+ EXPECT_EQ(waiting, 0);
}
/* tdm_client_vblank_wait */
TEST_P(TDMClient, ClientVblankIsWaitingNullObject)
{
unsigned int waiting = tdm_client_vblank_is_waiting(NULL);
- ASSERT_EQ(waiting, 0);
+ EXPECT_EQ(waiting, 0);
}
TEST_P(TDMClient, ClientCreateVOutput)
virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
if (virtual_conf == 0) {
- ASSERT_EQ(virtual_conf, 0);
+ EXPECT_EQ(virtual_conf, 0);
return;
}
- ASSERT_EQ(PrepareClient(), true);
+ EXPECT_EQ(PrepareClient(), true);
voutput = tdm_client_create_voutput(client, name, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(voutput, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(voutput, NULL);
tdm_client_voutput_destroy(voutput);
}
return;
server_pid = _tc_tdm_client_server_fork(pipe_parent, pipe_child);
- ASSERT_GT(server_pid, 0);
+ EXPECT_GT(server_pid, 0);
}
void TDMVirtualOutput::SetUpTestCase(void)
if (server_pid == -1)
ServerFork();
- ASSERT_EQ(PrepareVOutput(), true);
+ EXPECT_EQ(PrepareVOutput(), true);
}
void TDMVirtualOutput::TearDownTestCase(void)
if (this->voutput == NULL) {
virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
- ASSERT_EQ(virtual_conf, 0);
+ EXPECT_EQ(virtual_conf, 0);
return;
}
_tc_tdm_client_virutual_make_available_mode(modes, count);
ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
}
TEST_F(TDMVirtualOutput, FailTestSetAvailableModes)
if (this->voutput == NULL) {
virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
- ASSERT_EQ(virtual_conf, 0);
+ EXPECT_EQ(virtual_conf, 0);
return;
}
ret = tdm_client_voutput_set_available_modes(NULL, modes, count);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
ret = tdm_client_voutput_set_available_modes(this->voutput, NULL, count);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
}
TEST_F(TDMVirtualOutput, SetPhysicalSize)
if (this->voutput == NULL) {
virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
- ASSERT_EQ(virtual_conf, 0);
+ EXPECT_EQ(virtual_conf, 0);
return;
}
ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
}
TEST_F(TDMVirtualOutput, FailTestSetPhysicalSize)
if (this->voutput == NULL) {
virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
- ASSERT_EQ(virtual_conf, 0);
+ EXPECT_EQ(virtual_conf, 0);
return;
}
ret = tdm_client_voutput_set_physical_size(this->voutput, invalid_mmWidth, invalid_mmHeight);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
}
static void
if (this->voutput == NULL) {
virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
- ASSERT_EQ(virtual_conf, 0);
+ EXPECT_EQ(virtual_conf, 0);
return;
}
ret = tdm_client_voutput_add_commit_handler(this->voutput,
_tc_tdm_client_voutput_commit_handler,
&flag_callback_called);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
-// ASSERT_EQ(flag_callback_called, 1);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+// EXPECT_EQ(flag_callback_called, 1);
tdm_client_voutput_remove_commit_handler(this->voutput,
_tc_tdm_client_voutput_commit_handler,
if (this->voutput == NULL) {
virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
- ASSERT_EQ(virtual_conf, 0);
+ EXPECT_EQ(virtual_conf, 0);
return;
}
ret = tdm_client_voutput_commit_done(this->voutput);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
}
TEST_F(TDMVirtualOutput, GetClientOutput)
if (this->voutput == NULL) {
virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
- ASSERT_EQ(virtual_conf, 0);
+ EXPECT_EQ(virtual_conf, 0);
return;
}
output = tdm_client_voutput_get_client_output(this->voutput, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(output, NULL);
}
static void
if (this->voutput == NULL) {
virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
- ASSERT_EQ(virtual_conf, 0);
+ EXPECT_EQ(virtual_conf, 0);
return;
}
output = tdm_client_voutput_get_client_output(this->voutput, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(output, NULL);
ret = tdm_client_output_add_change_handler(output, _tc_voutput_output_handler_cb, &done);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
ret = tdm_client_output_add_change_handler(output, _tc_voutput_output_handler_cb2, &done2);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
_tc_tdm_client_virutual_make_available_mode(modes, count);
ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
ret = tdm_client_voutput_connect(this->voutput);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
ret = tdm_client_voutput_disconnect(this->voutput);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
while (!done2)
- ASSERT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
tdm_client_output_remove_change_handler(output, _tc_voutput_output_handler_cb, &done);
tdm_client_output_remove_change_handler(output, _tc_voutput_output_handler_cb2, &done2);
if (this->voutput == NULL) {
virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
- ASSERT_EQ(virtual_conf, 0);
+ EXPECT_EQ(virtual_conf, 0);
return;
}
output = tdm_client_voutput_get_client_output(this->voutput, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(output, NULL);
ret = tdm_client_output_add_change_handler(output, _tc_voutput_output_handler_cb, &done);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
ret = tdm_client_output_add_change_handler(output, _tc_voutput_output_handler_cb2, &done2);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
ret = tdm_client_output_add_change_handler(output, _tc_voutput_output_handler_cb3, &done3);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
_tc_tdm_client_virutual_make_available_mode(modes, count);
ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
ret = tdm_client_voutput_connect(this->voutput);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_client_voutput_set_mode(this->voutput, count - 1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_voutput_set_mode(this->voutput, count - 1), TDM_ERROR_NONE);
while (!done3)
- ASSERT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
ret = tdm_client_voutput_disconnect(this->voutput);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
while (!done2)
- ASSERT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_client_handle_events_timeout(this->client, 3000), TDM_ERROR_NONE);
tdm_client_output_remove_change_handler(output, _tc_voutput_output_handler_cb, &done);
tdm_client_output_remove_change_handler(output, _tc_voutput_output_handler_cb2, &done2);
if (this->voutput == NULL) {
virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
- ASSERT_EQ(virtual_conf, 0);
+ EXPECT_EQ(virtual_conf, 0);
return;
}
ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
_tc_tdm_client_virutual_make_available_mode(modes, count);
ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
ret = tdm_client_voutput_connect(this->voutput);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
tdm_client_handle_events_timeout(this->client, 50);
- ASSERT_EQ(tdm_client_voutput_set_mode(NULL, 0), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_client_voutput_set_mode(NULL, 0), TDM_ERROR_INVALID_PARAMETER);
ret = tdm_client_voutput_disconnect(this->voutput);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
tdm_client_handle_events_timeout(this->client, 0);
}
if (this->voutput == NULL) {
virtual_conf = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
- ASSERT_EQ(virtual_conf, 0);
+ EXPECT_EQ(virtual_conf, 0);
return;
}
ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
_tc_tdm_client_virutual_make_available_mode(modes, count);
ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
ret = tdm_client_voutput_connect(this->voutput);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
tdm_client_handle_events_timeout(this->client, 50);
- ASSERT_EQ(tdm_client_voutput_set_mode(this->voutput, -1), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_client_voutput_set_mode(this->voutput, -1), TDM_ERROR_INVALID_PARAMETER);
ret = tdm_client_voutput_disconnect(this->voutput);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
tdm_client_handle_events_timeout(this->client, 0);
}
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;
}
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();
}
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)
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)
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)
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)
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)
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);
}
}
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);
}
}
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)
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);
}
}
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)
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)
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);
}
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)
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;
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);
}
}
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)
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);
}
}
tdm_error ret;
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);
tdm_display_deinit(dpy);
}
TDMEnv::TearDown();
dpy = tdm_display_init(&ret);
- ASSERT_EQ(ret, TDM_ERROR_OPERATION_FAILED);
- ASSERT_EQ(dpy, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_OPERATION_FAILED);
+ EXPECT_EQ(dpy, NULL);
}
TEST_P(TDMEnv, DisplayInitFewTimes)
for (d = 0; d < 10; d++) {
dpy[d] = tdm_display_init(&ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(dpy[d], NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(dpy[d], NULL);
}
for (d = 0; d < 9; d++)
- ASSERT_EQ(dpy[d], dpy[d + 1]);
+ EXPECT_EQ(dpy[d], dpy[d + 1]);
for (d = 0; d < 10; d++)
tdm_display_deinit(dpy[d]);
tdm_error ret;
bufmgr = tbm_bufmgr_init(-1);
- ASSERT_NE(bufmgr, NULL);
+ EXPECT_NE(bufmgr, NULL);
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);
tdm_display_deinit(dpy);
tbm_bufmgr_deinit(bufmgr);
bool done;
int len;
- ASSERT_EQ(pipe(pipes), 0);
+ EXPECT_EQ(pipe(pipes), 0);
done = false;
source = tdm_event_loop_add_fd_handler(dpy, pipes[0], TDM_EVENT_LOOP_READABLE,
_tc_tdm_event_loop_fd_cb, &done, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(source, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(source, NULL);
len = write(pipes[1], "hello", 5);
- ASSERT_EQ(len, 5);
+ EXPECT_EQ(len, 5);
//TODO
// while (!done)
-// ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+// EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
tdm_event_loop_source_remove(source);
tdm_event_loop_source *source;
source = tdm_event_loop_add_fd_handler(NULL, 0, TDM_EVENT_LOOP_READABLE,
_tc_tdm_event_loop_fd_cb, NULL, &ret);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(source, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(source, NULL);
}
TEST_P(TDMEventLoop, EventLoopAddFdHandlerNullOther)
tdm_error ret;
tdm_event_loop_source *source;
source = tdm_event_loop_add_fd_handler(NULL, -1, TDM_EVENT_LOOP_READABLE, NULL, NULL, &ret);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(source, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(source, NULL);
}
TEST_P(TDMEventLoop, EventLoopSourceFdUpdate)
bool done;
int len;
- ASSERT_EQ(pipe(pipes), 0);
+ EXPECT_EQ(pipe(pipes), 0);
done = false;
source = tdm_event_loop_add_fd_handler(dpy, pipes[0], TDM_EVENT_LOOP_WRITABLE,
_tc_tdm_event_loop_fd_cb, &done, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(source, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(source, NULL);
- ASSERT_EQ(tdm_event_loop_source_fd_update(source, TDM_EVENT_LOOP_READABLE), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_event_loop_source_fd_update(source, TDM_EVENT_LOOP_READABLE), TDM_ERROR_NONE);
len = write(pipes[1], "hello", 5);
- ASSERT_EQ(len, 5);
+ EXPECT_EQ(len, 5);
//TODO
// while (!done)
-// ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+// EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
tdm_event_loop_source_remove(source);
TEST_P(TDMEventLoop, EventLoopSourceFdUpdateNullObject)
{
- ASSERT_EQ(tdm_event_loop_source_fd_update(NULL, TDM_EVENT_LOOP_READABLE), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_event_loop_source_fd_update(NULL, TDM_EVENT_LOOP_READABLE), TDM_ERROR_INVALID_PARAMETER);
}
static tdm_error
tdm_error ret;
tdm_event_loop_source *source;
source = tdm_event_loop_add_timer_handler(dpy, _tc_tdm_event_loop_timer_cb, NULL, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(source, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(source, NULL);
tdm_event_loop_source_remove(source);
}
tdm_error ret;
tdm_event_loop_source *source;
source = tdm_event_loop_add_timer_handler(NULL, _tc_tdm_event_loop_timer_cb, NULL, &ret);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(source, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(source, NULL);
}
tdm_error ret;
tdm_event_loop_source *source;
source = tdm_event_loop_add_timer_handler(dpy, NULL, NULL, &ret);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(source, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(source, NULL);
}
TEST_P(TDMEventLoop, EventLoopSourceTimerUpdate)
tdm_error ret;
tdm_event_loop_source *source;
source = tdm_event_loop_add_timer_handler(dpy, _tc_tdm_event_loop_timer_cb, NULL, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(source, NULL);
- ASSERT_EQ(tdm_event_loop_source_timer_update(source, 100), TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(source, NULL);
+ EXPECT_EQ(tdm_event_loop_source_timer_update(source, 100), TDM_ERROR_NONE);
//TODO
// while (!done)
-// ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+// EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
tdm_event_loop_source_remove(source);
}
TEST_P(TDMEventLoop, EventLoopSourceTimerUpdateNullObject)
{
- ASSERT_EQ(tdm_event_loop_source_timer_update(NULL, 100), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_event_loop_source_timer_update(NULL, 100), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMEventLoop, EventLoopSourceRemoveNullObject)
TEST_P(TDMHelper, HelperGetTime)
{
- ASSERT_GT(tdm_helper_get_time(), 0.0);
+ EXPECT_GT(tdm_helper_get_time(), 0.0);
}
TEST_P(TDMHelper, HelperDumpBufferXR24)
tbm_surface_h buffer;
buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_XRGB8888);
- ASSERT_NE(buffer, NULL);
+ EXPECT_NE(buffer, NULL);
tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
tbm_surface_h buffer;
buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
- ASSERT_NE(buffer, NULL);
+ EXPECT_NE(buffer, NULL);
tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
tdm_pos pos = {.x = 40, .y = 40, .w = TDM_UT_BUFFER_SIZE - 80, .h = TDM_UT_BUFFER_SIZE - 80};
buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
- ASSERT_NE(buffer, NULL);
+ EXPECT_NE(buffer, NULL);
tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
unsigned int color = 0xffffff00;
buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
- ASSERT_NE(buffer, NULL);
+ EXPECT_NE(buffer, NULL);
tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
tbm_surface_h buffer;
buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
- ASSERT_NE(buffer, NULL);
+ EXPECT_NE(buffer, NULL);
tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
tbm_surface_h buffer;
buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_XRGB8888);
- ASSERT_NE(buffer, NULL);
+ EXPECT_NE(buffer, NULL);
tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
tbm_surface_h buffer;
buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_YUV420);
- ASSERT_NE(buffer, NULL);
+ EXPECT_NE(buffer, NULL);
tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
tbm_surface_h buffer;
buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_NV12);
- ASSERT_NE(buffer, NULL);
+ EXPECT_NE(buffer, NULL);
tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
tbm_surface_h buffer;
buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_NV21);
- ASSERT_NE(buffer, NULL);
+ EXPECT_NE(buffer, NULL);
tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
int w = TDM_UT_INVALID_VALUE, h = TDM_UT_INVALID_VALUE;
buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
- ASSERT_NE(buffer, NULL);
+ EXPECT_NE(buffer, NULL);
tdm_helper_get_buffer_full_size(buffer, &w, &h);
- ASSERT_NE(w, TDM_UT_INVALID_VALUE);
- ASSERT_GE(w, tbm_surface_get_width(buffer));
- ASSERT_NE(h, TDM_UT_INVALID_VALUE);
- ASSERT_GE(h, tbm_surface_get_height(buffer));
+ EXPECT_NE(w, TDM_UT_INVALID_VALUE);
+ EXPECT_GE(w, tbm_surface_get_width(buffer));
+ EXPECT_NE(h, TDM_UT_INVALID_VALUE);
+ EXPECT_GE(h, tbm_surface_get_height(buffer));
tbm_surface_destroy(buffer);
}
tdm_pos sp, dp;
buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
- ASSERT_NE(buffer, NULL);
+ EXPECT_NE(buffer, NULL);
tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
- ASSERT_NE(temp, NULL);
+ EXPECT_NE(temp, NULL);
sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
- ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_NORMAL, 0), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_NORMAL, 0), TDM_ERROR_NONE);
tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name());
tdm_pos sp, dp;
buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
- ASSERT_NE(buffer, NULL);
+ EXPECT_NE(buffer, NULL);
tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
- ASSERT_NE(temp, NULL);
+ EXPECT_NE(temp, NULL);
sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
- ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_FLIPPED, 0), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_FLIPPED, 0), TDM_ERROR_NONE);
tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name());
tdm_pos sp, dp;
buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
- ASSERT_NE(buffer, NULL);
+ EXPECT_NE(buffer, NULL);
tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
- ASSERT_NE(temp, NULL);
+ EXPECT_NE(temp, NULL);
sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
- ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_90, 0), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_90, 0), TDM_ERROR_NONE);
tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name());
tdm_pos sp, dp;
buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
- ASSERT_NE(buffer, NULL);
+ EXPECT_NE(buffer, NULL);
tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
- ASSERT_NE(temp, NULL);
+ EXPECT_NE(temp, NULL);
sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
- ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_180, 0), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_180, 0), TDM_ERROR_NONE);
tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name());
tdm_pos sp, dp;
buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
- ASSERT_NE(buffer, NULL);
+ EXPECT_NE(buffer, NULL);
tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
- ASSERT_NE(temp, NULL);
+ EXPECT_NE(temp, NULL);
sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
- ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_270, 0), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_270, 0), TDM_ERROR_NONE);
tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name());
tdm_pos sp, dp;
buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_YUV420);
- ASSERT_NE(buffer, NULL);
+ EXPECT_NE(buffer, NULL);
tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_YUV420);
- ASSERT_NE(temp, NULL);
+ EXPECT_NE(temp, NULL);
sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
- ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_NORMAL, 0), TDM_ERROR_OPERATION_FAILED);
+ EXPECT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_NORMAL, 0), TDM_ERROR_OPERATION_FAILED);
tbm_surface_destroy(buffer);
tbm_surface_destroy(temp);
TEST_P(TDMHelper, HelperGetFD)
{
int fd = tdm_helper_get_fd("TDM_DRM_MASTER_FD");
- ASSERT_GE(fd, 0);
+ EXPECT_GE(fd, 0);
close(fd);
fd = tdm_helper_get_fd("BLURBLUR");
- ASSERT_EQ(fd, -1);
+ EXPECT_EQ(fd, -1);
}
TEST_P(TDMHelper, HelperSetFD)
tbm_surface_h dump;
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);
if (!tc_tdm_output_is_connected(output))
continue;
if (tc_tdm_output_is_hwc_enable(outputs[o]))
TDM_UT_SKIP_FLAG(0);
- ASSERT_EQ(tc_tdm_output_prepare(dpy, output, true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, output, true), true);
dump = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
- ASSERT_NE(dump, NULL);
+ EXPECT_NE(dump, NULL);
- ASSERT_EQ(tdm_helper_capture_output(output, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE,
+ EXPECT_EQ(tdm_helper_capture_output(output, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE,
_tc_tdm_helper_capture_cb, NULL), TDM_ERROR_NONE);
tdm_helper_dump_buffer_str(dump, NULL, (char*)typeid(*this).name());
{
tbm_surface_h dump = (tbm_surface_h)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE,
+ EXPECT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE,
_tc_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
for (int o = 0; o < output_count; o++) {
tdm_error ret;
tdm_output *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);
tdm_helper_output_commit_per_vblank_enabled(output);
}
tbm_surface_h dump = (tbm_surface_h)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE,
+ EXPECT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE,
_tc_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
for (int o = 0; o < output_count; o++) {
tdm_error ret;
tdm_output *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);
if (!tc_tdm_output_is_connected(output))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, output, true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, output, true), true);
}
tdm_helper_get_display_information(dpy, reply, &len);
TEST_P(TDMHelper, HelperCommitPerVblankEnabled)
{
- ASSERT_EQ(tdm_helper_commit_per_vblank_enabled(dpy), 0);
+ EXPECT_EQ(tdm_helper_commit_per_vblank_enabled(dpy), 0);
}
TEST_P(TDMHelper, HelperCommitPerVblankEnabledNullOBject)
{
- ASSERT_EQ(tdm_helper_commit_per_vblank_enabled(NULL), 0);
+ EXPECT_EQ(tdm_helper_commit_per_vblank_enabled(NULL), 0);
}
TEST_P(TDMHelper, HelperOutputCommitPerVblankEnabledNullObject)
{
- ASSERT_EQ(tdm_helper_output_commit_per_vblank_enabled(NULL), -1);
+ EXPECT_EQ(tdm_helper_output_commit_per_vblank_enabled(NULL), -1);
}
#ifdef TDM_UT_TEST_WITH_PARAMS
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(NULL, tdm_hwc_create_window(NULL, &error));
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_EQ(NULL, tdm_hwc_create_window(NULL, &error));
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
TEST_P(TDMHwc, CreateWindowSuccessful)
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
hw = tdm_hwc_create_window(hwc, &error);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
tdm_hwc_window_destroy(hw);
} else {
- ASSERT_EQ(NULL, tdm_hwc_create_window(hwc, &error));
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_EQ(NULL, tdm_hwc_create_window(hwc, &error));
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
}
}
tdm_error error;
error = tdm_hwc_get_video_supported_formats(NULL, NULL, NULL);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
TEST_P(TDMHwc, GetSupportedFormatsSuccessful)
if (hwc) {
error = tdm_hwc_get_video_supported_formats(hwc, &formats, &count);
if (error != TDM_ERROR_NOT_IMPLEMENTED) {
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
if (count > 0)
- ASSERT_NE(NULL, formats);
+ EXPECT_NE(NULL, formats);
}
} else {
error = tdm_hwc_get_video_supported_formats(hwc, &formats, &count);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
}
}
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
error = tdm_hwc_get_video_available_properties(NULL, &props, &count);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
error = tdm_hwc_get_video_available_properties(hwc, NULL, &count);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
error = tdm_hwc_get_video_available_properties(hwc, &props, NULL);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
} else {
error = tdm_hwc_get_video_available_properties(hwc, &props, &count);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
}
}
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
error = tdm_hwc_get_video_available_properties(hwc, &props, &count);
- ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
+ EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
} else {
error = tdm_hwc_get_video_available_properties(hwc, &props, &count);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
}
}
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
error = tdm_hwc_get_capabilities(NULL, &hwc_caps);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
error = tdm_hwc_get_capabilities(hwc, NULL);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
} else {
error = tdm_hwc_get_capabilities(hwc, &hwc_caps);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
}
}
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
error = tdm_hwc_get_capabilities(hwc, &hwc_caps);
- ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
+ EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
} else {
error = tdm_hwc_get_capabilities(hwc, &hwc_caps);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
}
}
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
error = tdm_hwc_get_available_properties(NULL, &props, &count);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
error = tdm_hwc_get_available_properties(hwc, NULL, &count);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
error = tdm_hwc_get_available_properties(hwc, &props, NULL);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
} else {
error = tdm_hwc_get_available_properties(hwc, &props, &count);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
}
}
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
error = tdm_hwc_get_available_properties(hwc, &props, &count);
- ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
+ EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
} else {
error = tdm_hwc_get_available_properties(hwc, &props, &count);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
}
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
queue = tdm_hwc_get_client_target_buffer_queue(NULL, &error);
- ASSERT_NE(TDM_ERROR_NONE, error);
- ASSERT_EQ(NULL, queue);
+ EXPECT_NE(TDM_ERROR_NONE, error);
+ EXPECT_EQ(NULL, queue);
queue = tdm_hwc_get_client_target_buffer_queue(NULL, NULL);
- ASSERT_EQ(NULL, queue);
+ EXPECT_EQ(NULL, queue);
} else {
- ASSERT_EQ(NULL, queue);
+ EXPECT_EQ(NULL, queue);
}
}
}
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
- ASSERT_NE(TDM_ERROR_NONE, error);
- ASSERT_EQ(NULL, queue);
+ EXPECT_NE(TDM_ERROR_NONE, error);
+ EXPECT_EQ(NULL, queue);
} else {
queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
- ASSERT_NE(TDM_ERROR_NONE, error);
- ASSERT_EQ(NULL, queue);
+ EXPECT_NE(TDM_ERROR_NONE, error);
+ EXPECT_EQ(NULL, queue);
}
}
}
tbm_surface_queue_h queue = NULL;
for (int o = 0; o < output_count; o++) {
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
tbm_surface_queue_destroy(queue);
- ASSERT_EQ(TDM_ERROR_NONE, error);
- ASSERT_NE(NULL, queue);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_NE(NULL, queue);
queue = tdm_hwc_get_client_target_buffer_queue(hwc, NULL);
tbm_surface_queue_destroy(queue);
- ASSERT_EQ(TDM_ERROR_NONE, error);
- ASSERT_NE(NULL, queue);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_NE(NULL, queue);
} else {
queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
- ASSERT_NE(TDM_ERROR_NONE, error);
- ASSERT_EQ(NULL, queue);
+ EXPECT_NE(TDM_ERROR_NONE, error);
+ EXPECT_EQ(NULL, queue);
queue = tdm_hwc_get_client_target_buffer_queue(hwc, NULL);
- ASSERT_NE(TDM_ERROR_NONE, error);
- ASSERT_EQ(NULL, queue);
+ EXPECT_NE(TDM_ERROR_NONE, error);
+ EXPECT_EQ(NULL, queue);
}
}
}
target_buff = tbm_surface_internal_create_with_flags(720, 1024,
TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
- ASSERT_NE(NULL, target_buff);
+ EXPECT_NE(NULL, target_buff);
error = tdm_hwc_set_client_target_buffer(NULL, target_buff, damage);
tbm_surface_internal_destroy(target_buff);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
TEST_P(TDMHwc, SetClientTargetBufferSuccessfulSetBuff)
tbm_surface_h target_buff = NULL;
for (int o = 0; o < output_count; o++) {
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
- ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
- ASSERT_NE(mode, NULL);
+ EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
+ EXPECT_NE(mode, NULL);
target_buff = tbm_surface_internal_create_with_flags(mode->hdisplay, mode->vdisplay,
TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
- ASSERT_NE(NULL, target_buff);
+ EXPECT_NE(NULL, target_buff);
error = tdm_hwc_set_client_target_buffer(hwc, target_buff, damage);
tbm_surface_internal_destroy(target_buff);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
} else {
error = tdm_hwc_set_client_target_buffer(hwc, target_buff, damage);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
}
}
tdm_region damage = {.num_rects = 0, .rects = NULL};
for (int o = 0; o < output_count; o++) {
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
error = tdm_hwc_set_client_target_buffer(hwc, NULL, damage);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
} else {
error = tdm_hwc_set_client_target_buffer(hwc, NULL, damage);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
}
}
uint32_t num_types;
error = tdm_hwc_validate(NULL, NULL, 0, &num_types);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
for (int o = 0; o < output_count; o++) {
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
error = tdm_hwc_validate(hwc, NULL, 0, NULL);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
} else {
error = tdm_hwc_validate(hwc, NULL, 0, NULL);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
}
}
uint32_t num_elements;
error = tdm_hwc_get_changed_composition_types(NULL, &num_elements, NULL, NULL);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
for (int o = 0; o < output_count; o++) {
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
error = tdm_hwc_get_changed_composition_types(hwc, NULL, NULL, NULL);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
} else {
error = tdm_hwc_get_changed_composition_types(hwc, NULL, NULL, NULL);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
}
}
TDM_UT_SKIP_FLAG(has_outputs);
error = tdm_hwc_accept_validation(NULL);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
TEST_P(TDMHwc, AcceptChangesFailNoHwc)
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
error = tdm_hwc_accept_validation(hwc);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
} else {
error = tdm_hwc_accept_validation(hwc);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
}
}
uint32_t get_num = 0;
for (int o = 0; o < output_count; o++) {
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
for (int w = 0; w < HWC_WIN_NUM; w++) {
hwc_wnds[w] = tdm_hwc_create_window(hwc, &error);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
error = tdm_hwc_window_set_composition_type(hwc_wnds[w], TDM_HWC_WIN_COMPOSITION_DEVICE);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
}
error = tdm_hwc_validate(hwc, hwc_wnds, HWC_WIN_NUM, &num_types);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
if (num_types > 0) {
changed_hwc_window = (tdm_hwc_window **)calloc(num_types, sizeof(tdm_hwc_window *));
get_num = num_types;
error = tdm_hwc_get_changed_composition_types(hwc, &get_num, changed_hwc_window, composition_types);
- ASSERT_EQ(TDM_ERROR_NONE, error);
- ASSERT_EQ(get_num, num_types);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(get_num, num_types);
error = tdm_hwc_accept_validation(hwc);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
free(composition_types);
free(changed_hwc_window);
for (int w = 0; w < HWC_WIN_NUM; w++)
tdm_hwc_window_destroy(hwc_wnds[w]);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
}
}
}
TDM_UT_SKIP_FLAG(has_outputs);
error = tdm_hwc_commit(NULL, 1, NULL, NULL);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
TEST_P(TDMHwc, CommitSuccessful)
uint32_t get_num = 0;
for (int o = 0; o < output_count; o++) {
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
for (int w = 0; w < HWC_WIN_NUM; w++) {
hwc_wnds[w] = tdm_hwc_create_window(hwc, &error);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
error = tdm_hwc_window_set_composition_type(hwc_wnds[w], TDM_HWC_WIN_COMPOSITION_DEVICE);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
}
error = tdm_hwc_validate(hwc, hwc_wnds, HWC_WIN_NUM, &num_types);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
if (num_types > 0) {
changed_hwc_window = (tdm_hwc_window **)calloc(num_types, sizeof(tdm_hwc_window *));
get_num = num_types;
error = tdm_hwc_get_changed_composition_types(hwc, &get_num, changed_hwc_window, composition_types);
- ASSERT_EQ(TDM_ERROR_NONE, error);
- ASSERT_EQ(get_num, num_types);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(get_num, num_types);
error = tdm_hwc_accept_validation(hwc);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
free(composition_types);
free(changed_hwc_window);
}
error = tdm_hwc_commit(hwc, 0, _tc_tdm_hwc_commit_cb, NULL);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
for (int w = 0; w < HWC_WIN_NUM; w++)
tdm_hwc_window_destroy(hwc_wnds[w]);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
}
}
}
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
error = tdm_hwc_set_property(NULL, 0, value);
- ASSERT_EQ(TDM_ERROR_INVALID_PARAMETER, error);
+ EXPECT_EQ(TDM_ERROR_INVALID_PARAMETER, error);
} else {
error = tdm_hwc_set_property(hwc, 0, value);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
}
}
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
error = tdm_hwc_get_available_properties(hwc, &props, &count);
- ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
+ EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
if (count == 0) {
error = tdm_hwc_set_property(hwc, 0, value);
- ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
+ EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
} else {
error = tdm_hwc_set_property(hwc, props[0].id, value);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
}
} else {
error = tdm_hwc_set_property(hwc, 0, value);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
}
}
hwc = tdm_output_get_hwc(outputs[o], &error);
if (hwc) {
error = tdm_hwc_get_property(NULL, 0, &value);
- ASSERT_EQ(TDM_ERROR_INVALID_PARAMETER, error);
+ EXPECT_EQ(TDM_ERROR_INVALID_PARAMETER, error);
} else {
error = tdm_hwc_get_property(hwc, 0, &value);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
}
}
if (hwc) {
error = tdm_hwc_get_available_properties(hwc, &props, &count);
- ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
+ EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
if (count == 0) {
error = tdm_hwc_get_property(hwc, 0, &value);
- ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
+ EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
} else {
error = tdm_hwc_get_property(hwc, props[0].id, &value);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
}
} else {
error = tdm_hwc_get_property(hwc, 0, &value);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
}
}
hwc = tdm_output_get_hwc(hwc, &error);
if (hwc) {
hw = tdm_hwc_create_window(hwc, &error);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
if (hw)
tdm_hwc_window_destroy(hw);
}
tbm_surface_queue_h queue = NULL;
queue = tdm_hwc_window_acquire_buffer_queue(NULL, &error);
- ASSERT_NE(TDM_ERROR_NONE, error);
- ASSERT_EQ(NULL, queue);
+ EXPECT_NE(TDM_ERROR_NONE, error);
+ EXPECT_EQ(NULL, queue);
queue = tdm_hwc_window_acquire_buffer_queue(NULL, NULL);
- ASSERT_EQ(NULL, queue);
+ EXPECT_EQ(NULL, queue);
}
TEST_P(TDMHwcWindow, GetBufferQueueSuccessful)
if (hwc) {
for (w = 0; w < HWC_WIN_NUM; w++) {
hwc_wins[w] = tdm_hwc_create_window(hwc, &error);
- ASSERT_NE(NULL, hwc_wins[w]);
+ EXPECT_NE(NULL, hwc_wins[w]);
}
info.src_config.format = TBM_FORMAT_ARGB8888;
for (w = 0; w < HWC_WIN_NUM; w++) {
error = tdm_hwc_window_set_info(hwc_wins[w], &info);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
queue = tdm_hwc_window_acquire_buffer_queue(hwc_wins[w], &error);
tdm_hwc_window_release_buffer_queue(hwc_wins[w], queue);
- ASSERT_EQ(TDM_ERROR_NONE, error);
- ASSERT_NE(NULL, queue);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_NE(NULL, queue);
queue = tdm_hwc_window_acquire_buffer_queue(hwc_wins[w], NULL);
tdm_hwc_window_release_buffer_queue(hwc_wins[w], queue);
- ASSERT_NE(NULL, queue);
+ EXPECT_NE(NULL, queue);
}
for (w = 0; w < HWC_WIN_NUM; w++)
tdm_error error = TDM_ERROR_NONE;
error = tdm_hwc_window_set_composition_type(NULL, TDM_HWC_WIN_COMPOSITION_DEVICE);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
TEST_P(TDMHwcWindow, SetCompositionTypeFailInvalieCompositionType)
hwc = tdm_output_get_hwc(hwc, &error);
if (hwc) {
hwc_win = tdm_hwc_create_window(hwc, &error);
- ASSERT_NE(NULL, hwc_win);
+ EXPECT_NE(NULL, hwc_win);
error = tdm_hwc_window_set_composition_type(hwc_win, tdm_hwc_window_composition(TDM_HWC_WIN_COMPOSITION_NONE - 1));
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
tdm_hwc_window_destroy(hwc_win);
}
}
if (hwc) {
for (w = 0; w < HWC_WIN_NUM; w++) {
hwc_wins[w] = tdm_hwc_create_window(hwc, &error);
- ASSERT_NE(NULL, hwc_wins[w]);
+ EXPECT_NE(NULL, hwc_wins[w]);
}
for (w = 0; w < HWC_WIN_NUM; w++) {
error = tdm_hwc_window_set_composition_type(hwc_wins[w], TDM_HWC_WIN_COMPOSITION_DEVICE);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
error = tdm_hwc_window_set_composition_type(hwc_wins[w], TDM_HWC_WIN_COMPOSITION_CLIENT);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
error = tdm_hwc_window_set_composition_type(hwc_wins[w], TDM_HWC_WIN_COMPOSITION_CURSOR);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
}
for (w = 0; w < HWC_WIN_NUM; w++)
tdm_region damage = {.num_rects = 0, .rects = NULL};
error = tdm_hwc_window_set_buffer_damage(NULL, damage);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
TEST_P(TDMHwcWindow, SetBufferDamageFailNullDamageRects)
hwc = tdm_output_get_hwc(hwc, &error);
if (hwc) {
hwc_win = tdm_hwc_create_window(hwc, &error);
- ASSERT_NE(NULL, hwc_win);
+ EXPECT_NE(NULL, hwc_win);
error = tdm_hwc_window_set_buffer_damage(hwc_win, damage);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
tdm_hwc_window_destroy(hwc_win);
}
}
if (hwc) {
for (int w = 0; w < HWC_WIN_NUM; w++) {
hwc_wins[w] = tdm_hwc_create_window(hwc, &error);
- ASSERT_NE(NULL, hwc_wins[w]);
+ EXPECT_NE(NULL, hwc_wins[w]);
error = tdm_hwc_window_set_buffer_damage(hwc_wins[w], damage);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
tdm_hwc_window_destroy(hwc_wins[w]);
}
}
tdm_hwc_window_info info = { 0 };
error = tdm_hwc_window_set_info(NULL, &info);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
for (int o = 0; o < output_count; o++) {
hwc = tdm_output_get_hwc(hwc, &error);
if (hwc) {
hwc_win = tdm_hwc_create_window(hwc, &error);
- ASSERT_NE(NULL, hwc_win);
+ EXPECT_NE(NULL, hwc_win);
error = tdm_hwc_window_set_info(hwc_win, NULL);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
tdm_hwc_window_destroy(hwc_win);
}
}
hwc = tdm_output_get_hwc(hwc, &error);
if (hwc) {
hwc_win = tdm_hwc_create_window(hwc, &error);
- ASSERT_NE(NULL, hwc_win);
+ EXPECT_NE(NULL, hwc_win);
error = tdm_hwc_window_set_info(hwc_win, &info);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
tdm_hwc_window_destroy(hwc_win);
}
}
tdm_error error = TDM_ERROR_NONE;
error = tdm_hwc_window_set_buffer(NULL, NULL);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
TEST_P(TDMHwcWindow, SetBufferSuccessful)
if (hwc) {
for (int w = 0; w < HWC_WIN_NUM; w++) {
hwc_wins[w] = tdm_hwc_create_window(hwc, &error);
- ASSERT_NE(NULL, hwc_wins[w]);
+ EXPECT_NE(NULL, hwc_wins[w]);
buffer = tbm_surface_create(256, 256, TBM_FORMAT_ARGB8888);
- ASSERT_NE(NULL, buffer);
+ EXPECT_NE(NULL, buffer);
error = tdm_hwc_window_set_buffer(hwc_wins[w], buffer);
tbm_surface_destroy(buffer);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
/* set NULL to the buffer */
error = tdm_hwc_window_set_buffer(hwc_wins[w], NULL);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
tdm_hwc_window_destroy(hwc_wins[w]);
}
int id = 1;
error = tdm_hwc_window_set_property(NULL, id, value);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
}
TEST_P(TDMHwcWindow, SetPropertyFailWrongId)
hwc = tdm_output_get_hwc(hwc, &error);
if (hwc) {
hwc_win = tdm_hwc_create_window(hwc, &error);
- ASSERT_NE(NULL, hwc_win);
+ EXPECT_NE(NULL, hwc_win);
error = tdm_hwc_window_set_property(hwc_win, id, value);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
tdm_hwc_window_destroy(hwc_win);
}
}
int id = 1;
error = tdm_hwc_window_get_property(NULL, id, &value);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
for (int o = 0; o < output_count; o++) {
hwc = tdm_output_get_hwc(hwc, &error);
if (hwc) {
hwc_win = tdm_hwc_create_window(hwc, &error);
- ASSERT_NE(NULL, hwc_win);
+ EXPECT_NE(NULL, hwc_win);
error = tdm_hwc_window_get_property(hwc_win, id, NULL);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
tdm_hwc_window_destroy(hwc_win);
}
}
hwc = tdm_output_get_hwc(hwc, &error);
if (hwc) {
hwc_win = tdm_hwc_create_window(hwc, &error);
- ASSERT_NE(NULL, hwc_win);
+ EXPECT_NE(NULL, hwc_win);
error = tdm_hwc_window_get_property(hwc_win, id, &value);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ EXPECT_NE(TDM_ERROR_NONE, error);
tdm_hwc_window_destroy(hwc_win);
}
}
if (tc_tdm_output_is_hwc_enable(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
- ASSERT_GT(count, 0);
+ EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
+ EXPECT_GT(count, 0);
layer_count += count;
layers = (tdm_layer**)realloc(layers, sizeof(tdm_layer*) * layer_count);
- ASSERT_NE(layers, NULL);
+ EXPECT_NE(layers, NULL);
for (int l = 0; l < count; l++) {
tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret);
- ASSERT_NE(layer, NULL);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(layer, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
layers[old_layer_count + l] = layer;
}
}
void TDMLayer::TearDown(void)
{
for (int l = 0; l < layer_count; l++) {
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
}
free(layers);
for (int l = 0; l < layer_count; l++) {
tdm_error ret;
tdm_output *output = tdm_layer_get_output(layers[l], &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(output, NULL);
}
}
tdm_error ret;
tdm_output *output = tdm_layer_get_output(NULL, &ret);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(output, NULL);
}
TEST_P(TDMLayer, LayerGetOutputNullParam)
for (int l = 0; l < layer_count; l++) {
tdm_output *output = tdm_layer_get_output(layers[l], NULL);
- ASSERT_NE(output, NULL);
+ EXPECT_NE(output, NULL);
}
}
for (int l = 0; l < layer_count; l++) {
tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_capabilities(layers[l], &capabilities), TDM_ERROR_NONE);
- ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_get_capabilities(layers[l], &capabilities), TDM_ERROR_NONE);
+ EXPECT_NE(capabilities, TDM_UT_INVALID_VALUE);
}
}
TDM_UT_SKIP_FLAG(has_layers);
tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(capabilities, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(capabilities, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMLayer, LayerGetCapabilitiesNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_get_capabilities(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_get_capabilities(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerGetAvailableFormats)
continue;
const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_available_formats(layers[l], &formats, &count), TDM_ERROR_NONE);
- ASSERT_NE(formats, NULL);
- ASSERT_GT(count, 0);
+ EXPECT_EQ(tdm_layer_get_available_formats(layers[l], &formats, &count), TDM_ERROR_NONE);
+ EXPECT_NE(formats, NULL);
+ EXPECT_GT(count, 0);
}
}
const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE);
- ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_get_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMLayer, LayerGetAvailableFormatsNullOther)
TDM_UT_SKIP_FLAG(has_layers);
if (!tc_tdm_layer_is_avaiable(layers[0]))
return;
- ASSERT_EQ(tdm_layer_get_available_formats(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_get_available_formats(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerGetAvailableProperties)
continue;
const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE);
- ASSERT_GE(count, 0);
+ EXPECT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE);
+ EXPECT_GE(count, 0);
if (count > 0)
- ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
+ EXPECT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
}
}
const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_available_properties(NULL, &props, &count), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(props, (const tdm_prop *)TDM_UT_INVALID_VALUE);
- ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_get_available_properties(NULL, &props, &count), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(props, (const tdm_prop *)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMLayer, LayerGetAvailablePropertiesNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_get_available_properties(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_get_available_properties(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerGetZpos)
TDM_UT_SKIP_FLAG(has_layers);
bool *check_table = (bool*)calloc(layer_count, output_count);
- ASSERT_NE(check_table, NULL);
+ EXPECT_NE(check_table, NULL);
for (int l = 0; l < layer_count; l++) {
if (!tc_tdm_layer_is_avaiable(layers[l]))
TDM_UT_SKIP_FLAG(has_layers);
int zpos = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_zpos(NULL, &zpos), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(zpos, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_get_zpos(NULL, &zpos), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(zpos, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMLayer, LayerGetZposNullParam)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_get_zpos(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_get_zpos(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, DISABLED_LayerSetProperty)
{
tdm_value value = {.s32 = 0};
- ASSERT_EQ(tdm_layer_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerGetProperty)
const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE);
- ASSERT_GE(count, 0);
+ EXPECT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE);
+ EXPECT_GE(count, 0);
if (count > 0) {
- ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
+ EXPECT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
for (int i = 0; i < count; i++) {
tdm_value value = {.s32 = TDM_UT_INVALID_VALUE};
- ASSERT_EQ(tdm_layer_get_property(layers[l], props[i].id, &value), TDM_ERROR_NONE);
- ASSERT_NE(value.s32, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_get_property(layers[l], props[i].id, &value), TDM_ERROR_NONE);
+ EXPECT_NE(value.s32, TDM_UT_INVALID_VALUE);
}
}
}
TDM_UT_SKIP_FLAG(has_layers);
tdm_value value = {.s32 = TDM_UT_INVALID_VALUE};
- ASSERT_EQ(tdm_layer_get_property(NULL, 0, &value), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(value.s32, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_get_property(NULL, 0, &value), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(value.s32, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMLayer, LayerGetPropertyNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_get_property(layers[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_get_property(layers[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerSetInfo)
continue;
tdm_info_layer info;
- ASSERT_EQ(tc_tdm_layer_fill_info(layers[l], NULL, NULL, &info), true);
- ASSERT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_fill_info(layers[l], NULL, NULL, &info), true);
+ EXPECT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE);
}
}
tdm_info_layer info;
memset(&info, 0, sizeof info);
- ASSERT_EQ(tdm_layer_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerSetInfoNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_set_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_set_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, DISABLED_LayerGetInfo)
tdm_info_layer temp;
- ASSERT_EQ(tdm_layer_get_info(NULL, &temp), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_get_info(NULL, &temp), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerGetInfoNullParam)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_get_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_get_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerGetBufferFlags)
continue;
unsigned int flags = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_buffer_flags(layers[l], &flags), TDM_ERROR_NONE);
- ASSERT_NE(flags, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_get_buffer_flags(layers[l], &flags), TDM_ERROR_NONE);
+ EXPECT_NE(flags, (unsigned int)TDM_UT_INVALID_VALUE);
}
}
TDM_UT_SKIP_FLAG(has_layers);
unsigned int flags = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_buffer_flags(NULL, &flags), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(flags, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_get_buffer_flags(NULL, &flags), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(flags, (unsigned int)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMLayer, LayerGetBufferFlagsNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_get_buffer_flags(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_get_buffer_flags(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
static void
if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
/* set buffer & commit for 100 times */
for (int t = 0; t < 10; t++) {
tbm_surface_h displaying_buffer = NULL;
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
while (displaying_buffer != buffers[next_buffer]) {
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
}
next_buffer++;
if (next_buffer == 3)
if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
/* set buffer & commit for 10 times */
for (int t = 0; t < 10; t++) {
tbm_surface_h displaying_buffer = NULL;
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
if (next_buffer == 3)
next_buffer = 0;
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
while (displaying_buffer != buffers[next_buffer]) {
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
}
next_buffer++;
if (next_buffer == 3)
TDM_UT_SKIP_FLAG(has_layers);
tbm_surface_h buffer = (tbm_surface_h)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_set_buffer(NULL, buffer), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_set_buffer(NULL, buffer), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerSetBufferNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_set_buffer(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_set_buffer(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerUnsetBuffer)
if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
}
}
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_unset_buffer(NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_unset_buffer(NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerUnsetBufferBeforeCommit)
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
/* set buffer & commit for 10 times */
for (int t = 0; t < 10; t++) {
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
if (next_buffer == 3)
next_buffer = 0;
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
if (next_buffer == 3)
next_buffer = 0;
}
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
DestroyBuffers();
}
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
DestroyBuffers();
}
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
DestroyBuffers();
}
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
DestroyBuffers();
}
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
/* set buffer & commit for 10 times */
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
done = false;
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
while (!done) {
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
DestroyBuffers();
}
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
/* set buffer & commit for 10 times */
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
done = false;
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
while (!done) {
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
next_buffer = 0;
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
DestroyBuffers();
}
tdm_error ret;
tdm_output *output = tdm_layer_get_output(layers[0], &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(output, NULL);
if (!tc_tdm_output_is_connected(output))
return;
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_commit(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_commit(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerCommitNullOther)
tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
- ASSERT_EQ(tdm_layer_commit(layers[0], NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[0], NULL, NULL), TDM_ERROR_NONE);
}
TEST_P(TDMLayer, LayerIsCommittingNullObject)
TDM_UT_SKIP_FLAG(has_layers);
unsigned int committing = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_is_committing(NULL, &committing), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(committing, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_is_committing(NULL, &committing), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(committing, (unsigned int)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMLayer, LayerIsCommittingNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_is_committing(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_is_committing(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerRemoveCommitHandler)
tdm_error ret;
tdm_output *output = tdm_layer_get_output(layers[l], &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(output, NULL);
if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[0]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[0]), true);
for (int t = 0; t < 10; t++) {
bool done1 = false, done2 = false, done3 = false;
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_remove_commit_handler(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_remove_commit_handler(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
while (!done1 || done2 || !done3) {
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
tdm_error ret;
tdm_output *output = tdm_layer_get_output(layers[l], &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(output, NULL);
if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
for (int t = 0; t < 10; t++) {
bool done1 = false, done2 = false, done3 = false;
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_remove_commit_handler(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_remove_commit_handler(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
while (!done1 || !done2 || !done3) {
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
bool *done = (bool*)user_data;
if (done)
*done = true;
- ASSERT_EQ(tdm_layer_remove_commit_handler(layer, _tc_tdm_layer_commit_cb2, user_data), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_remove_commit_handler(layer, _tc_tdm_layer_commit_cb2, user_data), TDM_ERROR_NONE);
}
TEST_P(TDMLayer, LayerRemoveCommitHandlerInHandler)
tdm_error ret;
tdm_output *output = tdm_layer_get_output(layers[l], &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(output, NULL);
if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
for (int t = 0; t < 10; t++) {
bool done1 = false, done2 = false, done3 = false;
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done3), TDM_ERROR_NONE);
while (!done1 || !done2 || !done3) {
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_remove_commit_handler(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_remove_commit_handler(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerRemoveCommitHandlerNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_remove_commit_handler(layers[0], NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_remove_commit_handler(layers[0], NULL, NULL), TDM_ERROR_NONE);
}
TEST_P(TDMLayer, LayerGetDisplayingBufferNullObject)
tbm_surface_h displaying_buffer;
tdm_error ret;
displaying_buffer = tdm_layer_get_displaying_buffer(NULL, &ret);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(displaying_buffer, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(displaying_buffer, NULL);
}
TEST_P(TDMLayer, LayerGetDisplayingBufferNullOther)
tbm_surface_h displaying_buffer;
displaying_buffer = tdm_layer_get_displaying_buffer(layers[0], NULL);
- ASSERT_EQ(displaying_buffer, NULL);
+ EXPECT_EQ(displaying_buffer, NULL);
}
TEST_P(TDMLayer, LayerIsUsableNullObject)
TDM_UT_SKIP_FLAG(has_layers);
unsigned int usable = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_is_usable(NULL, &usable), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(usable, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_is_usable(NULL, &usable), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(usable, (unsigned int)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMLayer, LayerSetBufferQueue)
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- ASSERT_EQ(tc_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue), true);
- ASSERT_NE(buffer_queue, NULL);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue), true);
+ EXPECT_NE(buffer_queue, NULL);
- ASSERT_EQ(tc_tdm_layer_set_buffer_queue(layers[l], buffer_queue), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer_queue(layers[l], buffer_queue), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], NULL, NULL), TDM_ERROR_NONE);
for (int t = 0; t < 10; t++) {
- ASSERT_EQ(tbm_surface_queue_dequeue(buffer_queue, &buffer), TBM_SURFACE_QUEUE_ERROR_NONE);
- ASSERT_NE(buffer, NULL);
+ EXPECT_EQ(tbm_surface_queue_dequeue(buffer_queue, &buffer), TBM_SURFACE_QUEUE_ERROR_NONE);
+ EXPECT_NE(buffer, NULL);
tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
- ASSERT_EQ(tbm_surface_queue_enqueue(buffer_queue, buffer), TBM_SURFACE_QUEUE_ERROR_NONE);
+ EXPECT_EQ(tbm_surface_queue_enqueue(buffer_queue, buffer), TBM_SURFACE_QUEUE_ERROR_NONE);
displaying_buffer = NULL;
while (displaying_buffer != buffer) {
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
}
}
- ASSERT_EQ(tdm_layer_unset_buffer_queue(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer_queue(layers[l]), TDM_ERROR_NONE);
DestroyBuffers();
}
tbm_surface_queue_h buffer_queue = (tbm_surface_queue_h)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_set_buffer_queue(NULL, buffer_queue), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_set_buffer_queue(NULL, buffer_queue), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerSetBufferQueueNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_set_buffer_queue(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_set_buffer_queue(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerUnsetBufferQueueNullObject)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_unset_buffer_queue(NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_unset_buffer_queue(NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerIsUsableNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_is_usable(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_is_usable(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerSetVideoPos)
if (!tc_tdm_layer_is_video_layer(layers[l]))
continue;
- ASSERT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_NONE);
}
}
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_set_video_pos(NULL, -1), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_set_video_pos(NULL, -1), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerSetVideoPosNoVideoLayer)
if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- ASSERT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_BAD_REQUEST);
}
}
capture = tdm_layer_create_capture(layers[l], &ret);
if (ret == TDM_ERROR_NONE)
- ASSERT_NE(capture, NULL);
+ EXPECT_NE(capture, NULL);
}
}
tdm_error ret;
tdm_capture *capture = tdm_layer_create_capture(NULL, &ret);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(capture, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(capture, NULL);
}
#ifdef TDM_UT_TEST_WITH_PARAMS
{
TDMDisplay::SetUp();
- ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
- ASSERT_GE(output_count, 0);
+ EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
+ EXPECT_GE(output_count, 0);
if (output_count > 0) {
outputs = (tdm_output**)calloc(output_count, sizeof(tdm_output*));
- ASSERT_NE(outputs, NULL);
+ EXPECT_NE(outputs, NULL);
for (int o = 0; o < output_count; o++) {
tdm_error ret;
tdm_output *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);
outputs[o] = output;
}
has_outputs = true;
{
if (outputs) {
for (int o = 0; o < output_count; o++) {
- ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1);
tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done2);
tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done3);
for (int o = 0; o < output_count; o++) {
tdm_error ret = (tdm_error)TDM_UT_INVALID_VALUE;
- ASSERT_NE(tdm_output_get_backend_module(outputs[o], &ret), NULL);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(tdm_output_get_backend_module(outputs[o], &ret), NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
}
}
TDM_UT_SKIP_FLAG(has_outputs);
tdm_error ret = (tdm_error)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_backend_module(NULL, &ret), NULL);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_backend_module(NULL, &ret), NULL);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetBackendModuleNullOther)
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- ASSERT_NE(tdm_output_get_backend_module(outputs[o], NULL), NULL);
+ EXPECT_NE(tdm_output_get_backend_module(outputs[o], NULL), NULL);
}
}
for (int o = 0; o < output_count; o++) {
tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_capabilities(outputs[o], &capabilities), TDM_ERROR_NONE);
- ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_capabilities(outputs[o], &capabilities), TDM_ERROR_NONE);
+ EXPECT_NE(capabilities, TDM_UT_INVALID_VALUE);
}
}
TDM_UT_SKIP_FLAG(has_outputs);
tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(capabilities, (tdm_output_capability)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(capabilities, (tdm_output_capability)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetCapabilitiesNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_capabilities(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_capabilities(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetModelInfo)
for (int o = 0; o < output_count; o++) {
const char *maker = NULL, *model = NULL, *name = NULL;
- ASSERT_EQ(tdm_output_get_model_info(outputs[o], &maker, &model, &name), TDM_ERROR_NONE);
- ASSERT_NE(maker, NULL);
- ASSERT_NE(model, NULL);
- ASSERT_NE(name, NULL);
+ EXPECT_EQ(tdm_output_get_model_info(outputs[o], &maker, &model, &name), TDM_ERROR_NONE);
+ EXPECT_NE(maker, NULL);
+ EXPECT_NE(model, NULL);
+ EXPECT_NE(name, NULL);
}
}
const char *model = (const char*)TDM_UT_INVALID_VALUE;
const char *name = (const char*)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_model_info(NULL, &maker, &model, &name), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(maker, (const char*)TDM_UT_INVALID_VALUE);
- ASSERT_EQ(model, (const char*)TDM_UT_INVALID_VALUE);
- ASSERT_EQ(name, (const char*)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_model_info(NULL, &maker, &model, &name), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(maker, (const char*)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(model, (const char*)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(name, (const char*)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetModelInfoNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_model_info(outputs[0], NULL, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_model_info(outputs[0], NULL, NULL, NULL), TDM_ERROR_NONE);
}
TEST_P(TDMOutput, OutputGetConnStatus)
for (int o = 0; o < output_count; o++) {
tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_conn_status(outputs[o], &status), TDM_ERROR_NONE);
- ASSERT_NE(status, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_conn_status(outputs[o], &status), TDM_ERROR_NONE);
+ EXPECT_NE(status, TDM_UT_INVALID_VALUE);
}
}
tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_conn_status(NULL, &status), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_conn_status(NULL, &status), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetConnStatusNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_conn_status(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_conn_status(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetOutputType)
for (int o = 0; o < output_count; o++) {
tdm_output_type type = (tdm_output_type)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_output_type(outputs[o], &type), TDM_ERROR_NONE);
- ASSERT_NE(type, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_output_type(outputs[o], &type), TDM_ERROR_NONE);
+ EXPECT_NE(type, TDM_UT_INVALID_VALUE);
}
}
TDM_UT_SKIP_FLAG(has_outputs);
tdm_output_type type = (tdm_output_type)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_output_type(NULL, &type), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(type, (tdm_output_type)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_output_type(NULL, &type), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(type, (tdm_output_type)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetOutputTypeNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_output_type(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_output_type(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetLayerCount)
for (int o = 0; o < output_count; o++) {
int count = TDM_UT_INVALID_VALUE;
if (tc_tdm_output_is_hwc_enable(outputs[o])) {
- ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_BAD_REQUEST);
- ASSERT_EQ(count, 0);
+ EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(count, 0);
} else {
- ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
- ASSERT_GT(count, 0);
+ EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
+ EXPECT_GT(count, 0);
}
}
}
TDM_UT_SKIP_FLAG(has_outputs);
int count = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_layer_count(NULL, &count), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_layer_count(NULL, &count), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetLayerCountNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_layer_count(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_layer_count(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetLayer)
int layer_count = TDM_UT_INVALID_VALUE;
if (tc_tdm_output_is_hwc_enable(outputs[o])) {
- ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_BAD_REQUEST);
- ASSERT_EQ(layer_count, 0);
+ EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(layer_count, 0);
layer = tdm_output_get_layer(outputs[o], 0, &ret);
- ASSERT_EQ(ret, TDM_ERROR_BAD_REQUEST);
- ASSERT_EQ(layer, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(layer, NULL);
} else {
- ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_NONE);
- ASSERT_GT(layer_count, 0);
+ EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_NONE);
+ EXPECT_GT(layer_count, 0);
for (int l = 0; l < layer_count; l++) {
tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(layer, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(layer, NULL);
}
}
}
tdm_error ret;
tdm_layer *layer = tdm_output_get_layer(NULL, 0, &ret);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(layer, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(layer, NULL);
}
TEST_P(TDMOutput, OutputGetLayerNullOther)
tdm_layer *layer;
if (tc_tdm_output_is_hwc_enable(outputs[0])) {
layer = tdm_output_get_layer(outputs[0], 0, NULL);
- ASSERT_EQ(layer, NULL);
+ EXPECT_EQ(layer, NULL);
} else {
layer = tdm_output_get_layer(outputs[0], 0, NULL);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
}
}
for (int o = 0; o < output_count; o++) {
int count = TDM_UT_INVALID_VALUE;
const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE);
- ASSERT_GE(count, 0);
+ EXPECT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE);
+ EXPECT_GE(count, 0);
if (count > 0)
- ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
+ EXPECT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
}
}
const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_available_properties(NULL, &props, &count), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(props, (const tdm_prop *)TDM_UT_INVALID_VALUE);
- ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_available_properties(NULL, &props, &count), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(props, (const tdm_prop *)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetAvailablePropertiesNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_available_properties(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_available_properties(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetAvailableModes)
int count = TDM_UT_INVALID_VALUE;
const tdm_output_mode *modes_array = (const tdm_output_mode *) TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes_array, &count), TDM_ERROR_NONE);
- ASSERT_GT(count, 0);
- ASSERT_TRUE(modes_array != NULL && modes_array != (const tdm_output_mode *)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes_array, &count), TDM_ERROR_NONE);
+ EXPECT_GT(count, 0);
+ EXPECT_TRUE(modes_array != NULL && modes_array != (const tdm_output_mode *)TDM_UT_INVALID_VALUE);
}
}
int count = TDM_UT_INVALID_VALUE;
const tdm_output_mode *modes_array = (const tdm_output_mode *) TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_available_modes(NULL, &modes_array, &count), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(modes_array, (const tdm_output_mode *) TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_available_modes(NULL, &modes_array, &count), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(modes_array, (const tdm_output_mode *) TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetAvailableModesNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_available_modes(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_available_modes(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetAvailableSize)
int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
int preferred_align = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
- ASSERT_NE(min_w, TDM_UT_INVALID_VALUE);
- ASSERT_NE(min_h, TDM_UT_INVALID_VALUE);
- ASSERT_NE(max_w, TDM_UT_INVALID_VALUE);
- ASSERT_NE(max_h, TDM_UT_INVALID_VALUE);
- ASSERT_NE(preferred_align, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
+ EXPECT_NE(min_w, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(min_h, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(max_w, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(max_h, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(preferred_align, TDM_UT_INVALID_VALUE);
}
}
int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
int preferred_align = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(min_w, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(min_h, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(max_w, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(max_h, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetAvailableSizeNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
}
TEST_P(TDMOutput, OutputGetCursorAvailableSize)
int major = TDM_UT_INVALID_VALUE;
int minor = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
if (major > 1 || (major >= 1 && minor >= 5)) {
for (int o = 0; o < output_count; o++) {
int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
int preferred_align = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
- ASSERT_NE(min_w, TDM_UT_INVALID_VALUE);
- ASSERT_NE(min_h, TDM_UT_INVALID_VALUE);
- ASSERT_NE(max_w, TDM_UT_INVALID_VALUE);
- ASSERT_NE(max_h, TDM_UT_INVALID_VALUE);
- ASSERT_NE(preferred_align, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
+ EXPECT_NE(min_w, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(min_h, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(max_w, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(max_h, TDM_UT_INVALID_VALUE);
+ EXPECT_NE(preferred_align, TDM_UT_INVALID_VALUE);
}
}
}
int major = TDM_UT_INVALID_VALUE;
int minor = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
if (major > 1 || (major >= 1 && minor >= 5)) {
for (int o = 0; o < output_count; o++) {
int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
int preferred_align = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_cursor_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_cursor_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(min_w, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(min_h, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(max_w, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(max_h, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
}
}
}
int major = TDM_UT_INVALID_VALUE;
int minor = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
if (major > 1 || (major >= 1 && minor >= 5))
- ASSERT_EQ(tdm_output_get_cursor_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_cursor_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
}
TEST_P(TDMOutput, OutputGetCursorAvailableSizeNoMatchVersion)
int major = TDM_UT_INVALID_VALUE;
int minor = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
if (major <= 1 && minor < 5) {
for (int o = 0; o < output_count; o++) {
int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
int preferred_align = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_BAD_REQUEST);
- ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE);
- ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(min_w, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(min_h, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(max_w, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(max_h, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
}
}
}
for (int o = 0; o < output_count; o++) {
unsigned int mmWidth = (unsigned int)TDM_UT_INVALID_VALUE;
unsigned int mmHeight = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_physical_size(outputs[o], &mmWidth, &mmHeight), TDM_ERROR_NONE);
- ASSERT_NE(mmWidth, (unsigned int)TDM_UT_INVALID_VALUE);
- ASSERT_NE(mmHeight, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_physical_size(outputs[o], &mmWidth, &mmHeight), TDM_ERROR_NONE);
+ EXPECT_NE(mmWidth, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_NE(mmHeight, (unsigned int)TDM_UT_INVALID_VALUE);
}
}
unsigned int mmWidth = (unsigned int)TDM_UT_INVALID_VALUE;
unsigned int mmHeight = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_physical_size(NULL, &mmWidth, &mmHeight), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(mmWidth, (unsigned int)TDM_UT_INVALID_VALUE);
- ASSERT_EQ(mmHeight, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_physical_size(NULL, &mmWidth, &mmHeight), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(mmWidth, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(mmHeight, (unsigned int)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetPhysicalSizeNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_physical_size(outputs[0], NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_physical_size(outputs[0], NULL, NULL), TDM_ERROR_NONE);
}
TEST_P(TDMOutput, OutputGetSubpixel)
for (int o = 0; o < output_count; o++) {
unsigned int subpixel = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_subpixel(outputs[o], &subpixel), TDM_ERROR_NONE);
- ASSERT_NE(subpixel, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_subpixel(outputs[o], &subpixel), TDM_ERROR_NONE);
+ EXPECT_NE(subpixel, (unsigned int)TDM_UT_INVALID_VALUE);
}
}
TDM_UT_SKIP_FLAG(has_outputs);
unsigned int subpixel = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_subpixel(NULL, &subpixel), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(subpixel, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_subpixel(NULL, &subpixel), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(subpixel, (unsigned int)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetSubpixelNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_subpixel(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_subpixel(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetPipe)
for (int o = 0; o < output_count; o++) {
unsigned int pipe = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_pipe(outputs[o], &pipe), TDM_ERROR_NONE);
- ASSERT_NE(pipe, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_pipe(outputs[o], &pipe), TDM_ERROR_NONE);
+ EXPECT_NE(pipe, (unsigned int)TDM_UT_INVALID_VALUE);
}
}
TDM_UT_SKIP_FLAG(has_outputs);
unsigned int pipe = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_pipe(NULL, &pipe), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(pipe, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_pipe(NULL, &pipe), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(pipe, (unsigned int)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetPipeNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_pipe(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_pipe(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetPrimaryIndex)
int primary_index = TDM_UT_INVALID_VALUE;
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
- ASSERT_EQ(tdm_output_get_primary_index(outputs[o], &primary_index), TDM_ERROR_NONE);
- ASSERT_NE(primary_index, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_primary_index(outputs[o], &primary_index), TDM_ERROR_NONE);
+ EXPECT_NE(primary_index, TDM_UT_INVALID_VALUE);
} else
TDM_UT_SKIP_FLAG(0);
}
TDM_UT_SKIP_FLAG(has_outputs);
int primary_index = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_primary_index(NULL, &primary_index), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(primary_index, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_primary_index(NULL, &primary_index), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(primary_index, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetPrimaryIndexNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_primary_index(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_primary_index(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, DISABLED_OutputSetProperty)
{
tdm_value value = {.s32 = 0};
- ASSERT_EQ(tdm_output_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetProperty)
for (int o = 0; o < output_count; o++) {
int count = TDM_UT_INVALID_VALUE;
const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE);
- ASSERT_GE(count, 0);
+ EXPECT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE);
+ EXPECT_GE(count, 0);
if (count > 0) {
- ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
+ EXPECT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
for (int i = 0; i < count; i++) {
tdm_value value = {.s32 = TDM_UT_INVALID_VALUE};
- ASSERT_EQ(tdm_output_get_property(outputs[o], props[i].id, &value), TDM_ERROR_NONE);
- ASSERT_NE(value.s32, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_property(outputs[o], props[i].id, &value), TDM_ERROR_NONE);
+ EXPECT_NE(value.s32, TDM_UT_INVALID_VALUE);
}
}
}
TDM_UT_SKIP_FLAG(has_outputs);
tdm_value value = {.s32 = TDM_UT_INVALID_VALUE};
- ASSERT_EQ(tdm_output_get_property(NULL, 0, &value), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(value.s32, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_property(NULL, 0, &value), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(value.s32, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetPropertyNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_property(outputs[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_property(outputs[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER);
}
static void
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
done1 = false;
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(done1, true);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(done1, true);
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_BAD_REQUEST);
}
TEST_P(TDMOutput, OutputAddChangeHandlerNullObject)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_add_change_handler(NULL, _tc_tdm_output_change_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_add_change_handler(NULL, _tc_tdm_output_change_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputAddChangeHandlerNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_add_change_handler(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputRemoveChangeHandler)
for (int o = 0; o < output_count; o++) {
for (int t = 0; t < 10; t++) {
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE);
tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
done1 = false;
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(done1, true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(done1, true);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
done1 = false;
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb2, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(done1, true);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb2, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(done1, true);
done2 = false;
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
- ASSERT_EQ(done2, true);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(done2, true);
done3 = false;
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb2, &done3), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(done3, true);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb2, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(done3, true);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
- ASSERT_NE(modes, NULL);
- ASSERT_GT(count, 0);
+ EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
+ EXPECT_NE(modes, NULL);
+ EXPECT_GT(count, 0);
for (int m = 0; m < count; m++)
- ASSERT_EQ(tdm_output_set_mode(outputs[o], modes + m), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_mode(outputs[o], modes + m), TDM_ERROR_NONE);
}
}
TDM_UT_SKIP_FLAG(has_outputs);
const tdm_output_mode *mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_set_mode(NULL, mode), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_set_mode(NULL, mode), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputSetModeNullOther)
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_set_mode(outputs[o], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_set_mode(outputs[o], NULL), TDM_ERROR_INVALID_PARAMETER);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
- ASSERT_NE(modes, NULL);
- ASSERT_GT(count, 0);
+ EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
+ EXPECT_NE(modes, NULL);
+ EXPECT_GT(count, 0);
for (int m = 0; m < count; m++) {
const tdm_output_mode *current_mode;
- ASSERT_EQ(tdm_output_set_mode(outputs[o], modes + m), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_mode(outputs[o], ¤t_mode), TDM_ERROR_NONE);
- ASSERT_EQ(current_mode, modes + m);
+ EXPECT_EQ(tdm_output_set_mode(outputs[o], modes + m), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(outputs[o], ¤t_mode), TDM_ERROR_NONE);
+ EXPECT_EQ(current_mode, modes + m);
}
}
}
TDM_UT_SKIP_FLAG(has_outputs);
const tdm_output_mode *current_mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_mode(NULL, ¤t_mode), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(current_mode, (const tdm_output_mode *)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_mode(NULL, ¤t_mode), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(current_mode, (const tdm_output_mode *)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetModeNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_mode(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_mode(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputGetModeNoSet)
for (int o = 0; o < output_count; o++) {
const tdm_output_mode *mode;
- ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
- ASSERT_EQ(mode, NULL);
+ EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
+ EXPECT_EQ(mode, NULL);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
if (tc_tdm_output_is_aod_enable(outputs[o])) {
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
} else {
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST);
}
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_set_dpms(NULL, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_set_dpms(NULL, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputSetDpmsNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)-1), TDM_ERROR_BAD_REQUEST);
- ASSERT_EQ(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)INT_MAX), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)-1), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)INT_MAX), TDM_ERROR_BAD_REQUEST);
}
TEST_P(TDMOutput, OutputSetDpmsAsync)
continue;
done1 = false;
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms_async(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms_async(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
while (!done1)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
- ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_OFF);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
+ EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_OFF);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
- ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_STANDBY);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
+ EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_STANDBY);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
- ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_SUSPEND);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
+ EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_SUSPEND);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
- ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_ON);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
+ EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_ON);
if (tc_tdm_output_is_aod_enable(outputs[o])) {
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
- ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_AOD);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
+ EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_AOD);
} else {
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST);
}
}
}
TDM_UT_SKIP_FLAG(has_outputs);
tdm_output_dpms dpms_value = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_dpms(NULL, &dpms_value), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(dpms_value, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_dpms(NULL, &dpms_value), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(dpms_value, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMOutput, OutputGetDpmsNullOther)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_get_dpms(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_get_dpms(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputWaitVblank)
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
for (int t = 0; t < 10; t++) {
double start, end, interval;
done1 = false;
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
while (!done1)
- 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));
}
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_wait_vblank(NULL, 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_wait_vblank(NULL, 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputWaitVblankNullOther)
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, NULL, NULL), TDM_ERROR_NONE);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_NONE);
usleep(1100000);
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
- ASSERT_GT(tdm_helper_output_vblank_timer_expired(outputs[o]), 0);
+ EXPECT_GT(tdm_helper_output_vblank_timer_expired(outputs[o]), 0);
}
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[0], 0, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[0], 0, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputWaitVblankInterval)
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
/* start from 1 */
for (int t = 1; t < 10; t++) {
done1 = false;
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
while (!done1)
- 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));
}
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
/* start from 1 */
for (int t = 1; t < 10; t++) {
interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
start = tdm_helper_get_time();
while (!done1 || !done2 || !done3)
- 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));
}
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], false), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], false), true);
for (int t = 0; t < 10; t++) {
bool done = false;
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done), TDM_ERROR_NONE);
if (t == 9)
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
/* start from 1 */
for (int t = 1; t < 10; t++) {
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
tdm_output_remove_vblank_handler(outputs[o], _tc_tdm_output_done_cb, &done2);
while (!done1 || done2 || !done3)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
/* start from 1 */
for (int t = 1; t < 10; t++) {
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
tdm_output_remove_vblank_handler(outputs[o], _tc_tdm_output_done_cb, NULL);
while (!done1 || !done2 || !done3)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
/* start from 1 */
for (int t = 1; t < 10; t++) {
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
while (!done1 || !done2 || !done3)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
for (int t = 0; t < 10; t++) {
double start, end, interval;
done1 = false;
start = tdm_helper_get_time();
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
while (!done1)
- 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));
} else
TDM_UT_SKIP_FLAG(0);
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_commit(NULL, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_output_commit(NULL, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputCommitNullOther)
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
if (!tc_tdm_output_is_hwc_enable(outputs[o]))
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
else
TDM_UT_SKIP_FLAG(0);
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
if (!tc_tdm_output_is_hwc_enable(outputs[o]))
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF);
else
TDM_UT_SKIP_FLAG(0);
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
if (!tc_tdm_output_is_hwc_enable(outputs[o]))
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF);
else
TDM_UT_SKIP_FLAG(0);
}
if (!tc_tdm_output_is_aod_enable(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
for (int t = 0; t < 10; t++) {
done1 = false;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
while (!done1)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
- ASSERT_EQ(tdm_output_get_primary_index(outputs[o], &index), TDM_ERROR_NONE);
- ASSERT_NE(index, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_output_get_primary_index(outputs[o], &index), TDM_ERROR_NONE);
+ EXPECT_NE(index, TDM_UT_INVALID_VALUE);
} else
TDM_UT_SKIP_FLAG(0);
layer = tdm_output_get_layer(outputs[o], index, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(layer, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(layer, NULL);
- ASSERT_EQ(tdm_layer_commit(layer, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layer, NULL, NULL), TDM_ERROR_NONE);
if (!tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
else
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_BAD_REQUEST);
}
}
for (int o = 0; o < output_count; o++) {
if (!tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_BAD_REQUEST);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
for (int t = 0; t < 10; t++) {
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
while (!done1 || !done2 || !done3)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
} else
TDM_UT_SKIP_FLAG(0);
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
for (int t = 0; t < 10; t++) {
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
tdm_output_remove_commit_handler(outputs[o], _tc_tdm_output_done_cb, &done2);
while (!done1 || done2 || !done3)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
} else
TDM_UT_SKIP_FLAG(0);
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
for (int t = 0; t < 10; t++) {
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
tdm_output_remove_commit_handler(outputs[o], _tc_tdm_output_done_cb, NULL);
while (!done1 || !done2 || !done3)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
} else
TDM_UT_SKIP_FLAG(0);
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
for (int t = 0; t < 10; t++) {
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done3), TDM_ERROR_NONE);
while (!done1 || !done2 || !done3)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
} else
TDM_UT_SKIP_FLAG(0);
}
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 */
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() */
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);
}
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)
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)
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);
}
{
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;
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);
}
{
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 */
{
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++) {
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);
}
{
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);
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);
}
{
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);
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);
}
{
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;
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);
}
{
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() */
{
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() */
{
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() */
{
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);
}
}
{
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);
}
}
{
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);
}
}
{
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;
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);
}
}
{
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);
}
}
{
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);
}
}
{
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);
}
}
{
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);
}
}
{
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);
}
}
{
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);
}
}
{
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;
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));
}
}
}
{
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;
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++) {
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));
}
}
}
{
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;
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 */
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);
}
}
}
{
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;
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));
}
}
}
{
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;
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));
}
}
}
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);
}
}
{
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);
}
}
{
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;
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);
}
}
{
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);
}
}
{
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;
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));
}
}
}
{
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;
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));
}
}
}
{
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;
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));
}
}
}
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));
}
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;
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);
}
}
{
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);
}
}
projects / platform / core / uifw / libtdm.git / commitdiff