change all symbol and file name.
Change-Id: Id48ccad285938dfcbb8f136c71592806c120d47e
-if HAVE_UTEST
-SUBDIRS = . include protocol common src backends client tools utests
+if HAVE_HALTESTS
+SUBDIRS = . include protocol common src backends client tools haltests
else
SUBDIRS = . include protocol common src backends client tools
endif
# Enable quiet compiles on automake 1.11.
m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
-AC_ARG_WITH(utests, AS_HELP_STRING([--with-utests=yes/no], [whether build/run unit tests or not]),
- [ utests="$withval" ],
- [ utests="no" ])
+AC_ARG_WITH(haltests, AS_HELP_STRING([--with-haltests=yes/no], [whether build/run unit tests or not]),
+ [ haltests="$withval" ],
+ [ haltests="no" ])
-AM_CONDITIONAL(HAVE_UTEST, test "x$utests" = "xyes")
+AM_CONDITIONAL(HAVE_HALTESTS, test "x$haltests" = "xyes")
AC_PATH_PROG([wayland_scanner], [wayland-scanner])
if test x$wayland_scanner = x; then
client/libtdm-client.pc
client/Makefile
tools/Makefile
- utests/Makefile])
+ haltests/Makefile])
echo ""
echo "$PACKAGE_STRING will be compiled with:"
--- /dev/null
+bin_PROGRAMS = tdm-haltests
+
+tdm_haltests_SOURCES = \
+ src/tc_tdm_main.cpp \
+ src/tc_tdm_log.cpp \
+ src/tc_tdm_env.cpp \
+ src/tc_tdm_event_loop.cpp \
+ src/tc_tdm_buffer.cpp \
+ src/tc_tdm_helper.cpp \
+ src/tc_tdm_vblank.cpp \
+ src/tc_tdm_display.cpp \
+ src/tc_tdm_output.cpp \
+ src/tc_tdm_layer.cpp \
+ src/tc_tdm_client.cpp \
+ src/tc_tdm_backend_env.cpp \
+ src/tc_tdm_backend_display.cpp \
+ src/tc_tdm_backend_pp.cpp \
+ src/tc_tdm_backend_capture.cpp
+
+tdm_haltests_SOURCES += \
+ ../tools/buffers.c
+
+tdm_haltests_CXXFLAGS = \
+ $(CXXFLAGS) \
+ $(TDM_CFLAGS) \
+ -I../src \
+ -I../include \
+ -I../client \
+ -I../tools \
+ -I$(includedir)/gtest \
+ -fpermissive
+# The flag -w is used, because there are many warnings in libtdm's sources.
+# Warnings occur because we build project with g++.
+# In C++ we need to use explicit types conversion.
+
+tdm_haltests_LDFLAGS = \
+ ${LDFLAGS} \
+ $(TDM_LIBS) \
+ $(top_builddir)/src/libtdm.la \
+ $(top_builddir)/client/libtdm-client.la \
+ $(top_builddir)/common/libtdm-common.la \
+ -lgtest
+
+check:
+ ./tdm-haltests
#define TDM_UT_DUMP_DIR "/tmp/tdm_dump"
#define TDM_UT_INVALID_VALUE -42
#define TDM_UT_BUFFER_SIZE 256
-#define TDM_UT_VBLANK_NAME "ut_tdm_vblank"
+#define TDM_UT_VBLANK_NAME "tc_tdm_vblank"
using ::testing::TestWithParam;
using ::testing::Bool;
extern "C" void __gcov_flush(void);
#endif
-tdm_error ut_tdm_display_handle_events(tdm_display *dpy);
-bool ut_tdm_display_has_pp_capability(tdm_display *dpy);
-bool ut_tdm_display_has_capture_capability(tdm_display *dpy);
+tdm_error tc_tdm_display_handle_events(tdm_display *dpy);
+bool tc_tdm_display_has_pp_capability(tdm_display *dpy);
+bool tc_tdm_display_has_capture_capability(tdm_display *dpy);
-bool ut_tdm_buffer_create(int width, int height, tbm_format format, int flags, bool fill,
+bool tc_tdm_buffer_create(int width, int height, tbm_format format, int flags, bool fill,
int count, tbm_surface_h *buffers);
-bool ut_tdm_output_is_async_dpms_enable(tdm_output *output);
-bool ut_tdm_output_is_hwc_enable(tdm_output *output);
-bool ut_tdm_output_is_aod_enable(tdm_output *output);
-bool ut_tdm_output_is_connected(tdm_output *output);
-bool ut_tdm_output_mode_setting(tdm_output *output);
-bool ut_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill);
-bool ut_tdm_output_prepare_all_output(tdm_display *dpy, tdm_output **outputs, int output_count, bool fill);
-bool ut_tdm_output_unset(tdm_display *dpy, tdm_output *output);
-double ut_tdm_output_get_vblank_interval_time(tdm_output *output);
-tdm_layer *ut_tdm_output_get_primary_layer(tdm_output *output);
-
-bool ut_tdm_layer_is_cursor_layer(tdm_layer *layer);
-bool ut_tdm_layer_is_primary_layer(tdm_layer *layer);
-bool ut_tdm_layer_is_video_layer(tdm_layer *layer);
-bool ut_tdm_layer_support_scale(tdm_layer *layer);
-bool ut_tdm_layer_support_no_crop(tdm_layer *layer);
-bool ut_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer_count, bool fill);
-bool ut_tdm_layer_prepare_buffer_queue(tdm_layer *layer, tbm_surface_queue_h *buffer_queue);
-bool ut_tdm_layer_fill_info(tdm_layer *layer, tbm_surface_h buffer, tbm_surface_queue_h buffer_queue, tdm_info_layer *info);
-bool ut_tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer);
-bool ut_tdm_layer_set_buffer_with_pos(tdm_layer *layer, tbm_surface_h buffer, tdm_pos *pos);
-unsigned int ut_tdm_layer_get_output_pipe(tdm_layer *layer);
-tbm_format ut_tdm_layer_find_best_format(tdm_layer *layer);
-bool ut_tdm_layer_is_avaiable(tdm_layer *layer);
-
-bool ut_tdm_pp_fill_info(tbm_surface_h srcbuf, tbm_surface_h dstbuf, tdm_transform transform, tdm_info_pp *info);
-bool ut_tdm_capture_fill_info(tdm_output *output, tbm_surface_h buffer, tdm_transform transform,
+bool tc_tdm_output_is_async_dpms_enable(tdm_output *output);
+bool tc_tdm_output_is_hwc_enable(tdm_output *output);
+bool tc_tdm_output_is_aod_enable(tdm_output *output);
+bool tc_tdm_output_is_connected(tdm_output *output);
+bool tc_tdm_output_mode_setting(tdm_output *output);
+bool tc_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill);
+bool tc_tdm_output_prepare_all_output(tdm_display *dpy, tdm_output **outputs, int output_count, bool fill);
+bool tc_tdm_output_unset(tdm_display *dpy, tdm_output *output);
+double tc_tdm_output_get_vblank_interval_time(tdm_output *output);
+tdm_layer *tc_tdm_output_get_primary_layer(tdm_output *output);
+
+bool tc_tdm_layer_is_cursor_layer(tdm_layer *layer);
+bool tc_tdm_layer_is_primary_layer(tdm_layer *layer);
+bool tc_tdm_layer_is_video_layer(tdm_layer *layer);
+bool tc_tdm_layer_support_scale(tdm_layer *layer);
+bool tc_tdm_layer_support_no_crop(tdm_layer *layer);
+bool tc_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer_count, bool fill);
+bool tc_tdm_layer_prepare_buffer_queue(tdm_layer *layer, tbm_surface_queue_h *buffer_queue);
+bool tc_tdm_layer_fill_info(tdm_layer *layer, tbm_surface_h buffer, tbm_surface_queue_h buffer_queue, tdm_info_layer *info);
+bool tc_tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer);
+bool tc_tdm_layer_set_buffer_with_pos(tdm_layer *layer, tbm_surface_h buffer, tdm_pos *pos);
+unsigned int tc_tdm_layer_get_output_pipe(tdm_layer *layer);
+tbm_format tc_tdm_layer_find_best_format(tdm_layer *layer);
+bool tc_tdm_layer_is_avaiable(tdm_layer *layer);
+
+bool tc_tdm_pp_fill_info(tbm_surface_h srcbuf, tbm_surface_h dstbuf, tdm_transform transform, tdm_info_pp *info);
+bool tc_tdm_capture_fill_info(tdm_output *output, tbm_surface_h buffer, tdm_transform transform,
tdm_capture_type type, int frequency, bool stretch, tdm_info_capture *info);
/******************************************************************************/
void TearDown(void) { TDMBackendBasic::TearDown(); }
};
-char ut_tdm_backend_getchar(void);
+char tc_tdm_backend_getchar(void);
#define TDM_UT_ASK_YNR(fmt, ...) \
do { \
char ch; \
do { \
printf(fmt" [Y]es, [n]o, [r]etry): ", ##__VA_ARGS__); \
- ch = ut_tdm_backend_getchar(); \
+ ch = tc_tdm_backend_getchar(); \
} while(ch != 'y' && ch != 'n' && ch != 'r'); \
if (ch == 'n') \
GTEST_FATAL_FAILURE_("tc failed"); \
*
**************************************************************************/
-#include "ut_tdm.h"
+#include "tc_tdm.h"
/* LCOV_EXCL_START */
class TDMBackendCapture : public TDMBackendDisplay
ASSERT_TRUE(preferred_align == -1 || preferred_align > 0);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
}
}
tdm_capture_destroy(capture);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_unset(dpy, outputs[o]), true);
+ ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
}
DestroyBuffers();
tdm_error ret;
int count;
int primary_zpos, zpos;
- tdm_layer *primary = ut_tdm_output_get_primary_layer(outputs[output_idx]);
+ tdm_layer *primary = tc_tdm_output_get_primary_layer(outputs[output_idx]);
TDM_UT_RETURN_FALSE_IF_FAIL(primary != NULL);
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_layer_count(outputs[output_idx], &count) == TDM_ERROR_NONE);
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_zpos(primary, &primary_zpos) == TDM_ERROR_NONE);
tdm_error ret;
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
capture = tdm_output_create_capture(outputs[o], &ret);
TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
TDM_UT_RETURN_FALSE_IF_FAIL(capture != NULL);
- TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[0], 0, false, 3, buffers) == true);
- TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_capture_fill_info(outputs[o], buffers[0], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false, &info) == true);
+ TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[0], 0, false, 3, buffers) == true);
+ TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_capture_fill_info(outputs[o], buffers[0], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false, &info) == true);
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_capture_set_info(capture, &info) == TDM_ERROR_NONE);
output = outputs[o];
flags |= TBM_BO_SCANOUT;
}
- TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_buffer_create(w, h, fmt, flags, false, 3, buffers) == true);
- TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_capture_fill_info(outputs[output_idx], buffers[0], t, c, frequency, stretch, &info) == true);
+ TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_buffer_create(w, h, fmt, flags, false, 3, buffers) == true);
+ TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_capture_fill_info(outputs[output_idx], buffers[0], t, c, frequency, stretch, &info) == true);
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_capture_set_info(capture, &info) == TDM_ERROR_NONE);
output = outputs[output_idx];
ASSERT_NE(output, NULL);
ASSERT_NE(dst_layer, NULL);
- ASSERT_EQ(ut_tdm_layer_set_buffer_with_pos(dst_layer, buffers[b], pos), true);
+ 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);
}
}
static void
-_ut_tdm_capture_fit_rect(int src_w, int src_h, int dst_w, int dst_h, tdm_pos *fit)
+_tc_tdm_capture_fit_rect(int src_w, int src_h, int dst_w, int dst_h, tdm_pos *fit)
{
float rw, rh;
}
bool
-ut_tdm_capture_fill_info(tdm_output *output, tbm_surface_h buffer, tdm_transform transform,
+tc_tdm_capture_fill_info(tdm_output *output, tbm_surface_h buffer, tdm_transform transform,
tdm_capture_type type, int frequency, bool stretch, tdm_info_capture *info)
{
int bw, bh;
info->dst_config.pos.w = tbm_surface_get_width(buffer);
info->dst_config.pos.h = tbm_surface_get_height(buffer);
} else {
- _ut_tdm_capture_fit_rect(mode->hdisplay, mode->vdisplay,
+ _tc_tdm_capture_fit_rect(mode->hdisplay, mode->vdisplay,
tbm_surface_get_width(buffer), tbm_surface_get_height(buffer),
&info->dst_config.pos);
}
}
static void
-_ut_tdm_capture_done_cb(tdm_capture *capture, tbm_surface_h buffer, void *user_data)
+_tc_tdm_capture_done_cb(tdm_capture *capture, tbm_surface_h buffer, void *user_data)
{
bool *done = (bool*)user_data;
if (done)
ASSERT_EQ(TestPrepareDefault(), true);
- ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb, NULL), TDM_ERROR_NONE);
+ ASSERT_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, _ut_tdm_capture_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_capture_set_done_handler(NULL, _tc_tdm_capture_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMBackendCapture, CaptureSetDoneHandlerNullOther)
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
for (int f = 0; f < format_count; f++) {
ASSERT_EQ(TestPrepareDefault(), true);
- ASSERT_EQ(ut_tdm_output_unset(dpy, output), true);
+ ASSERT_EQ(tc_tdm_output_unset(dpy, output), true);
ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
}
static void
-_ut_tdm_capture_done_cb2(tdm_capture *capture, tbm_surface_h buffer, void *user_data)
+_tc_tdm_capture_done_cb2(tdm_capture *capture, tbm_surface_h buffer, void *user_data)
{
int *done = (int*)user_data;
if (done)
const tdm_output_mode *mode = NULL;
int f = 0;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
ASSERT_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, _ut_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE);
+ ASSERT_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);
const tdm_output_mode *mode = NULL;
int f = 0;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
ASSERT_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, _ut_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE);
+ ASSERT_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);
for (int o = 0; o < output_count; o++) {
const tdm_output_mode *mode = NULL;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
ASSERT_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, _ut_tdm_capture_done_cb, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, &done), TDM_ERROR_NONE);
retry:
for (int b = 0; b < 3; b++) {
ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
#if 0
char temp[256];
for (int o = 0; o < output_count; o++) {
const tdm_output_mode *mode = NULL;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
ASSERT_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, _ut_tdm_capture_done_cb, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, &done), TDM_ERROR_NONE);
retry:
for (int b = 0; b < 3; b++) {
ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
#if 0
char temp[256];
for (int o = 0; o < output_count; o++) {
const tdm_output_mode *mode = NULL;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true);
done = 0;
- ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb2, &done), TDM_ERROR_NONE);
+ ASSERT_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_commit(capture), TDM_ERROR_NONE);
while (done != 3)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
for (int b = 0; b < 3; b++) {
#if 0
}
static void
-_ut_tdm_backend_capture_buffer_release_cb(tbm_surface_h buffer, void *user_data)
+_tc_tdm_backend_capture_buffer_release_cb(tbm_surface_h buffer, void *user_data)
{
TDMBackendCapture *backend_capture = (TDMBackendCapture*)user_data;
- tdm_buffer_remove_release_handler(buffer, _ut_tdm_backend_capture_buffer_release_cb, backend_capture);
+ 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);
}
static void
-_ut_tdm_capture_stream_done_cb(tdm_capture *capture, tbm_surface_h buffer, void *user_data)
+_tc_tdm_capture_stream_done_cb(tdm_capture *capture, tbm_surface_h buffer, void *user_data)
{
TDMBackendCapture *backend_capture = (TDMBackendCapture*)user_data;
snprintf(temp, sizeof temp, "f%d_b%d", f, b);
DumpBuffer(b, temp);
#endif
- tdm_buffer_add_release_handler(buffer, _ut_tdm_backend_capture_buffer_release_cb, (void*)backend_capture);
+ tdm_buffer_add_release_handler(buffer, _tc_tdm_backend_capture_buffer_release_cb, (void*)backend_capture);
backend_capture->ShowBuffer(b, &backend_capture->dst_pos);
break;
}
for (int o = 0; o < output_count; o++) {
const tdm_output_mode *mode = NULL;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
ASSERT_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, _ut_tdm_capture_stream_done_cb, (void*)this), TDM_ERROR_NONE);
+ ASSERT_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);
ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
while (!stream_exit)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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);
for (int o = 0; o < output_count; o++) {
const tdm_output_mode *mode = NULL;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
ASSERT_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, _ut_tdm_capture_stream_done_cb, (void*)this), TDM_ERROR_NONE);
+ ASSERT_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);
ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE);
while (!stream_exit)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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);
*
**************************************************************************/
-#include "ut_tdm.h"
+#include "tc_tdm.h"
/* LCOV_EXCL_START */
int old_layer_count = layer_count, count = TDM_UT_INVALID_VALUE;
tdm_error ret;
- if (ut_tdm_output_is_hwc_enable(outputs[o]))
+ if (tc_tdm_output_is_hwc_enable(outputs[o]))
continue;
ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
}
char
-ut_tdm_backend_getchar(void)
+tc_tdm_backend_getchar(void)
{
int c = getchar();
int ch = c;
const tdm_output_mode *best = NULL;
int count = TDM_UT_INVALID_VALUE;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
tdm_output_dpms got_dpms = TDM_OUTPUT_DPMS_OFF;
tdm_output_dpms set_dpms = TDM_OUTPUT_DPMS_ON;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
for (int o = 0; o < output_count; o++) {
tdm_layer *layer;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
+ 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);
- layer = ut_tdm_output_get_primary_layer(outputs[o]);
+ layer = tc_tdm_output_get_primary_layer(outputs[o]);
ASSERT_NE(layer, NULL);
retry:
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
- ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
+ ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
+ ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
tdm_layer *layer;
int next_buffer = 0;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
+ 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);
- layer = ut_tdm_output_get_primary_layer(outputs[o]);
+ layer = tc_tdm_output_get_primary_layer(outputs[o]);
ASSERT_NE(layer, NULL);
retry:
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 3, true), true);
+ ASSERT_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(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
+ 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);
usleep(40000); /* 40 ms */
next_buffer++;
}
static void
-_ut_tdm_backend_output_commit_cb(tdm_output *output, unsigned int sequence,
+_tc_tdm_backend_output_commit_cb(tdm_output *output, unsigned int sequence,
unsigned int tv_sec, unsigned int tv_usec,
void *user_data)
{
for (int o = 0; o < output_count; o++) {
tdm_layer *layer;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
+ 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);
- layer = ut_tdm_output_get_primary_layer(outputs[o]);
+ layer = tc_tdm_output_get_primary_layer(outputs[o]);
ASSERT_NE(layer, NULL);
retry:
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
- ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
+ ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
+ ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
bool done = false;
- TDM_UT_ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE,
+ TDM_UT_ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _tc_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE,
"Check output_commit(), output_set_commit_handler()");
while (!done)
- TDM_UT_ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE,
+ TDM_UT_ASSERT_TRUE(tc_tdm_display_handle_events(dpy) == TDM_ERROR_NONE,
"Check display_get_fd(), display_handle_events()");
TDM_UT_ASK_YNR("* Successed to display a frame to a primary layer? (output: %d)", o);
for (int o = 0; o < output_count; o++) {
tdm_layer *layer;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
+ 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);
- layer = ut_tdm_output_get_primary_layer(outputs[o]);
+ layer = tc_tdm_output_get_primary_layer(outputs[o]);
ASSERT_NE(layer, NULL);
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, false), true);
- ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
+ ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, false), true);
+ ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
if (tdm_layer_get_output(layers[l], &ret) != outputs[o])
continue;
ASSERT_EQ(ret, TDM_ERROR_NONE);
- if (ut_tdm_layer_is_primary_layer(layers[l]))
+ if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_cursor_layer(layers[l]))
+ if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true);
- ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[0]), true);
+ 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);
DestroyBuffers();
}
for (int o = 0; o < output_count; o++) {
tdm_layer *layer;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
+ 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);
- layer = ut_tdm_output_get_primary_layer(outputs[o]);
+ layer = tc_tdm_output_get_primary_layer(outputs[o]);
ASSERT_NE(layer, NULL);
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, false), true);
- ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
+ ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, false), true);
+ ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
if (tdm_layer_get_output(layers[l], &ret) != outputs[o])
continue;
ASSERT_EQ(ret, TDM_ERROR_NONE);
- if (ut_tdm_layer_is_primary_layer(layers[l]))
+ if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_cursor_layer(layers[l]))
+ if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
retry:
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ ASSERT_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(ut_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_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
usleep(40000); /* 40 ms */
next_buffer++;
}
static void
-_ut_tdm_backend_output_done_cb(tdm_output *output, unsigned int sequence,
+_tc_tdm_backend_output_done_cb(tdm_output *output, unsigned int sequence,
unsigned int tv_sec, unsigned int tv_usec,
void *user_data)
{
for (int o = 0; o < output_count; o++) {
tdm_layer *layer;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
+ 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);
- layer = ut_tdm_output_get_primary_layer(outputs[o]);
+ layer = tc_tdm_output_get_primary_layer(outputs[o]);
ASSERT_NE(layer, NULL);
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
- ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
+ ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
+ ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
double start, end, interval;
bool done;
- interval = ut_tdm_output_get_vblank_interval_time(outputs[o]);
+ interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
done = false;
start = tdm_helper_get_time();
- TDM_UT_ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done) == TDM_ERROR_NONE,
+ TDM_UT_ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done) == TDM_ERROR_NONE,
"Check output_wait_vblank(), output_set_vblank_handler()");
while (!done)
- TDM_UT_ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE,
+ TDM_UT_ASSERT_TRUE(tc_tdm_display_handle_events(dpy) == TDM_ERROR_NONE,
"Check display_get_fd(), display_handle_events()");
end = tdm_helper_get_time();
for (int o = 0; o < output_count; o++) {
tdm_layer *layer;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
+ 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);
- layer = ut_tdm_output_get_primary_layer(outputs[o]);
+ layer = tc_tdm_output_get_primary_layer(outputs[o]);
ASSERT_NE(layer, NULL);
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
- ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
+ ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
+ ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
double start, end, interval;
bool done;
- interval = ut_tdm_output_get_vblank_interval_time(outputs[o]);
+ interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
done = false;
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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 */
for (int o = 0; o < output_count; o++) {
tdm_layer *layer;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
+ 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);
- layer = ut_tdm_output_get_primary_layer(outputs[o]);
+ layer = tc_tdm_output_get_primary_layer(outputs[o]);
ASSERT_NE(layer, NULL);
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
- ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
+ ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
+ ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
double start, end, interval;
bool done1, done2, done3;
- interval = ut_tdm_output_get_vblank_interval_time(outputs[o]);
+ interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done3), TDM_ERROR_NONE);
+ 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);
start = tdm_helper_get_time();
while (!done1 || !done2 || !done3)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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 */
tdm_error ret;
tdm_pp *pp;
- if (!ut_tdm_display_has_pp_capability(dpy)) {
+ if (!tc_tdm_display_has_pp_capability(dpy)) {
TDM_UT_INFO("PP not supported");
return;
}
{
tdm_pp_capability capabilities = (tdm_pp_capability)0;
- if (!ut_tdm_display_has_pp_capability(dpy)) {
+ if (!tc_tdm_display_has_pp_capability(dpy)) {
TDM_UT_INFO("PP not supported");
return;
}
TEST_P(TDMBackendBasic, VerifyPPAvaiableSize)
{
- if (!ut_tdm_display_has_pp_capability(dpy)) {
+ if (!tc_tdm_display_has_pp_capability(dpy)) {
TDM_UT_INFO("PP not supported");
return;
}
TEST_P(TDMBackendBasic, VerifyPPAvaiableFormats)
{
- if (!ut_tdm_display_has_pp_capability(dpy)) {
+ if (!tc_tdm_display_has_pp_capability(dpy)) {
TDM_UT_INFO("PP not supported");
return;
}
TEST_P(TDMBackendBasic, VerifyCaptureObject)
{
- if (!ut_tdm_display_has_capture_capability(dpy)) {
+ if (!tc_tdm_display_has_capture_capability(dpy)) {
TDM_UT_INFO("Capture not supported.");
return;
}
continue;
}
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
capture = tdm_output_create_capture(outputs[o], &ret);
TEST_P(TDMBackendBasic, VerifyCaptureAvaiableSize)
{
- if (!ut_tdm_display_has_capture_capability(dpy)) {
+ if (!tc_tdm_display_has_capture_capability(dpy)) {
TDM_UT_INFO("Capture not supported.");
return;
}
TEST_P(TDMBackendBasic, VerifyCaptureAvaiableFormats)
{
- if (!ut_tdm_display_has_capture_capability(dpy)) {
+ if (!tc_tdm_display_has_capture_capability(dpy)) {
TDM_UT_INFO("Capture not supported.");
return;
}
const tdm_output_mode *mode = NULL;
unsigned int flags = 0;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- layer = ut_tdm_output_get_primary_layer(outputs[o]);
+ layer = tc_tdm_output_get_primary_layer(outputs[o]);
ASSERT_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);
for (int f = 0; f < format_count; f++) {
- ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
+ 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);
retry:
TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
- ASSERT_EQ(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ ASSERT_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(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
+ ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
done = false;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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]);
TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat)
{
- ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
+ ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
for (int l = 0; l < layer_count; l++) {
tdm_error ret;
output = tdm_layer_get_output(layer, &ret);
ASSERT_EQ(ret, TDM_ERROR_NONE);
- if (!ut_tdm_output_is_connected(output))
+ if (!tc_tdm_output_is_connected(output))
continue;
- if (ut_tdm_layer_is_primary_layer(layer))
+ if (tc_tdm_layer_is_primary_layer(layer))
continue;
- if (ut_tdm_layer_is_cursor_layer(layer))
+ if (tc_tdm_layer_is_cursor_layer(layer))
continue;
ASSERT_EQ(tdm_output_get_pipe(output, &pipe), 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(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ ASSERT_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(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
+ ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
done = false;
- ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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]);
TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize)
{
- ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
+ ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
for (int l = 0; l < layer_count; l++) {
tdm_error ret;
output = tdm_layer_get_output(layer, &ret);
ASSERT_EQ(ret, TDM_ERROR_NONE);
- if (!ut_tdm_output_is_connected(output))
+ if (!tc_tdm_output_is_connected(output))
continue;
- if (ut_tdm_layer_is_primary_layer(layer))
+ if (tc_tdm_layer_is_primary_layer(layer))
continue;
- if (ut_tdm_layer_is_cursor_layer(layer))
+ if (tc_tdm_layer_is_cursor_layer(layer))
continue;
ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
int h = mode->vdisplay - diffh * (f + 1);
retry:
TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
- ASSERT_EQ(ut_tdm_buffer_create(w, h, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ ASSERT_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(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
+ ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
done = false;
- ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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]);
TEST_P(TDMBackendDisplay, VerifyOverlayLayerScale)
{
- ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
+ ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
for (int l = 0; l < layer_count; l++) {
tdm_error ret;
ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
- if (!ut_tdm_output_is_connected(output))
+ if (!tc_tdm_output_is_connected(output))
continue;
- if (ut_tdm_layer_is_primary_layer(layer))
+ if (tc_tdm_layer_is_primary_layer(layer))
continue;
- if (ut_tdm_layer_is_cursor_layer(layer))
+ if (tc_tdm_layer_is_cursor_layer(layer))
continue;
- if (!ut_tdm_layer_support_scale(layer)) {
+ if (!tc_tdm_layer_support_scale(layer)) {
TDM_UT_INFO("no scale capability. (output: %d, layer: %d)", pipe, l);
continue;
}
for (int f = 0; f < format_count; f++) {
retry:
TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
- ASSERT_EQ(ut_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ ASSERT_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);
tbm_surface_h displaying_buffer;
ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
done = false;
- ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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]);
TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition)
{
- ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
+ ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
for (int l = 0; l < layer_count; l++) {
tdm_error ret;
output = tdm_layer_get_output(layer, &ret);
ASSERT_EQ(ret, TDM_ERROR_NONE);
- if (!ut_tdm_output_is_connected(output))
+ if (!tc_tdm_output_is_connected(output))
continue;
- if (ut_tdm_layer_is_primary_layer(layer))
+ if (tc_tdm_layer_is_primary_layer(layer))
continue;
- if (ut_tdm_layer_is_cursor_layer(layer))
+ if (tc_tdm_layer_is_cursor_layer(layer))
continue;
ASSERT_EQ(tdm_output_get_pipe(output, &pipe), 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(ut_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ ASSERT_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++) {
ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
done = false;
- ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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]);
TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop)
{
- ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
+ ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
for (int l = 0; l < layer_count; l++) {
tdm_error ret;
ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
- if (!ut_tdm_output_is_connected(output))
+ if (!tc_tdm_output_is_connected(output))
continue;
- if (ut_tdm_layer_is_primary_layer(layer))
+ if (tc_tdm_layer_is_primary_layer(layer))
continue;
- if (ut_tdm_layer_is_cursor_layer(layer))
+ if (tc_tdm_layer_is_cursor_layer(layer))
continue;
- if (ut_tdm_layer_support_no_crop(layer)) {
+ if (tc_tdm_layer_support_no_crop(layer)) {
TDM_UT_INFO("no crop capability. (output: %d, layer: %d)", pipe, l);
continue;
}
for (int f = 0; f < format_count; f++) {
retry:
TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
- ASSERT_EQ(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ ASSERT_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);
tbm_surface_h displaying_buffer;
ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
done = false;
- ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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]);
/* should be debugged int emulator kernel */
TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOnToOff)
{
- ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
+ ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[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);
/* should be debugged int emulator kernel */
TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOffToOn)
{
- ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
+ ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[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);
TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOnBeforeSet)
{
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
+ 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);
}
}
TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffBeforeSet)
{
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
+ 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);
}
}
TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithoutCommit)
{
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
- tdm_layer *layer = ut_tdm_output_get_primary_layer(outputs[o]);
+ tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]);
ASSERT_NE(layer, NULL);
ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithCommit)
{
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
- tdm_layer *layer = ut_tdm_output_get_primary_layer(outputs[o]);
+ tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]);
ASSERT_NE(layer, NULL);
ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
TEST_P(TDMBackendDisplay, VerifyLayerGetInfo)
{
- ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
+ ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
tbm_surface_h displaying_buffer;
tdm_error ret;
tdm_info_layer info, temp;
- tdm_layer *layer = ut_tdm_output_get_primary_layer(outputs[o]);
+ tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]);
ASSERT_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(ut_tdm_layer_fill_info(layer, displaying_buffer, NULL, &info), true);
+ 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);
}
*
**************************************************************************/
-#include "ut_tdm.h"
+#include "tc_tdm.h"
/* LCOV_EXCL_START */
*
**************************************************************************/
-#include "ut_tdm.h"
+#include "tc_tdm.h"
/* LCOV_EXCL_START */
{
TDMBackendDisplay::SetUp();
- if (!ut_tdm_display_has_pp_capability(dpy))
+ if (!tc_tdm_display_has_pp_capability(dpy))
return;
ASSERT_EQ(tdm_display_get_pp_capabilities(dpy, &capabilities), TDM_ERROR_NONE);
ASSERT_TRUE(preferred_align == -1 || preferred_align > 0);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[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(ut_tdm_output_prepare(dpy, output, false), true);
+ 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);
break;
dst_flags |= TBM_BO_SCANOUT;
}
- TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_buffer_create(sw, sh, sf, src_flags, true, 3, srcbuf) == true);
- TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_buffer_create(dw, dh, df, dst_flags, false, 3, dstbuf) == true);
- TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_pp_fill_info(srcbuf[0], dstbuf[0], t, &info) == true);
+ TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_buffer_create(sw, sh, sf, src_flags, true, 3, srcbuf) == true);
+ TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_buffer_create(dw, dh, df, dst_flags, false, 3, dstbuf) == true);
+ TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_pp_fill_info(srcbuf[0], dstbuf[0], t, &info) == true);
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_pp_set_info(pp, &info) == TDM_ERROR_NONE);
return true;
tdm_error ret;
int count;
int primary_zpos, zpos;
- tdm_layer *primary = ut_tdm_output_get_primary_layer(output);
+ tdm_layer *primary = tc_tdm_output_get_primary_layer(output);
TDM_UT_RETURN_FALSE_IF_FAIL(primary != NULL);
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_layer_count(output, &count) == TDM_ERROR_NONE);
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_zpos(primary, &primary_zpos) == TDM_ERROR_NONE);
tdm_error ret;
int count;
int primary_zpos, zpos;
- tdm_layer *primary = ut_tdm_output_get_primary_layer(output);
+ tdm_layer *primary = tc_tdm_output_get_primary_layer(output);
TDM_UT_RETURN_FALSE_IF_FAIL(primary != NULL);
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_layer_count(output, &count) == TDM_ERROR_NONE);
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_zpos(primary, &primary_zpos) == TDM_ERROR_NONE);
}
static void
-_ut_tdm_backend_pp_output_commit_cb(tdm_output *output, unsigned int sequence,
+_tc_tdm_backend_pp_output_commit_cb(tdm_output *output, unsigned int sequence,
unsigned int tv_sec, unsigned int tv_usec,
void *user_data)
{
bool done = false;
- ASSERT_EQ(ut_tdm_layer_set_buffer(dst_layer, dstbuf[b]), true);
- ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_pp_output_commit_cb, &done), TDM_ERROR_NONE);
+ 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);
while (!done) {
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
bool
-ut_tdm_pp_fill_info(tbm_surface_h srcbuf, tbm_surface_h dstbuf, tdm_transform transform, tdm_info_pp *info)
+tc_tdm_pp_fill_info(tbm_surface_h srcbuf, tbm_surface_h dstbuf, tdm_transform transform, tdm_info_pp *info)
{
int bw, bh;
{
const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
- if (ut_tdm_display_has_pp_capability(dpy))
+ if (tc_tdm_display_has_pp_capability(dpy))
ASSERT_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);
TEST_P(TDMBackendPP, PPDispalyGetAvaiableFormatsNullOther)
{
- if (ut_tdm_display_has_pp_capability(dpy)) {
+ 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);
}
int max_w = TDM_UT_INVALID_VALUE;
int max_h = TDM_UT_INVALID_VALUE;
int preferred_align = TDM_UT_INVALID_VALUE;
- if (ut_tdm_display_has_pp_capability(dpy))
+ 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);
else
ASSERT_EQ(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
TEST_P(TDMBackendPP, PPDispalyGetAvaiableSizeNullOther)
{
- if (ut_tdm_display_has_pp_capability(dpy)) {
+ 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);
}
TEST_P(TDMBackendPP, PPDestroy)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
ASSERT_EQ(PreparePP(), true);
tdm_pp_destroy(pp);
TEST_P(TDMBackendPP, PPDestroyNullObject)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
tdm_pp_destroy(NULL);
}
TEST_P(TDMBackendPP, PPSetInfoNullObject)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
tdm_info_pp info;
memset(&info, 0, sizeof info);
TEST_P(TDMBackendPP, PPSetInfoNullOther)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ 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);
}
static void
-_ut_tdm_pp_done_cb(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst, void *user_data)
+_tc_tdm_pp_done_cb(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst, void *user_data)
{
bool *done = (bool*)user_data;
if (done)
TEST_P(TDMBackendPP, PPSetDoneHandler)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
ASSERT_EQ(PreparePP(), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, NULL), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, NULL), TDM_ERROR_NONE);
}
TEST_P(TDMBackendPP, PPSetDoneHandlerNullObject)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
- ASSERT_EQ(tdm_pp_set_done_handler(NULL, _ut_tdm_pp_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_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(ut_tdm_display_has_pp_capability(dpy));
+ 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);
TEST_P(TDMBackendPP, PPAttach)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
ASSERT_EQ(PreparePP(), true);
TEST_P(TDMBackendPP, PPAttachNullObject)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
tbm_surface_h srcbuf = (tbm_surface_h)TDM_UT_BUFFER_SIZE;
tbm_surface_h dstbuf = (tbm_surface_h)TDM_UT_BUFFER_SIZE;
TEST_P(TDMBackendPP, PPAttachNullOther)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
ASSERT_EQ(PreparePP(), true);
TEST_P(TDMBackendPP, PPCommit)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
ASSERT_EQ(PreparePP(), true);
TEST_P(TDMBackendPP, PPCommitNullOBject)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
ASSERT_EQ(tdm_pp_commit(NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMBackendPP, PPConvertUnderlay)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
FindLayerUnderPrimary();
TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f],
TDM_TRANSFORM_NORMAL), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
retry:
for (int b = 0; b < 3; b++) {
ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
#if 0
char temp[256];
TEST_P(TDMBackendPP, PPConvertOverlay)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
FindLayerOverPrimary();
TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f],
TDM_TRANSFORM_NORMAL), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
retry:
for (int b = 0; b < 3; b++) {
ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
#if 0
char temp[256];
TEST_P(TDMBackendPP, PPConvertScale)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
FindLayerUnderPrimary();
mode->hdisplay, mode->vdisplay, dst_formats[f],
TDM_TRANSFORM_NORMAL), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
retry:
for (int b = 0; b < 3; b++) {
ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
#if 0
char temp[256];
TEST_P(TDMBackendPP, PPConvertTransform)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
FindLayerUnderPrimary();
TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f],
(tdm_transform)t), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
retry:
for (int b = 0; b < 3; b++) {
ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
#if 0
char temp[256];
TEST_P(TDMBackendPP, PPConvertCSC)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
TDM_UT_SKIP_FLAG(!(capabilities & TDM_PP_CAPABILITY_NO_CSC));
FindLayerUnderPrimary();
TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[df],
TDM_TRANSFORM_NORMAL), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE);
retry:
for (int b = 0; b < 3; b++) {
ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
#if 0
char temp[256];
static void
-_ut_tdm_pp_done_cb2(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst, void *user_data)
+_tc_tdm_pp_done_cb2(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst, void *user_data)
{
int *done = (int*)user_data;
if (done)
/* some backend doens't implement correctly for attaching */
TEST_P(TDMBackendPP, DISABLED_PPAttachFewTimesInOneCommit)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
ASSERT_EQ(PreparePP(), true);
TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
TDM_TRANSFORM_NORMAL), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb2, &done), TDM_ERROR_NONE);
+ ASSERT_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);
ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE);
while (done != 3)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
for (int b = 0; b < 3; b++)
ShowBuffer(b);
TEST_P(TDMBackendPP, PPDestroyWithoutCommit)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
ASSERT_EQ(PreparePP(), true);
TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
TDM_TRANSFORM_NORMAL), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb2, NULL), TDM_ERROR_NONE);
+ ASSERT_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);
TEST_P(TDMBackendPP, PPDestroyBeforeDone)
{
- TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy));
+ TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy));
ASSERT_EQ(PreparePP(), true);
TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f],
TDM_TRANSFORM_NORMAL), true);
- ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb2, NULL), TDM_ERROR_NONE);
+ ASSERT_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);
*
**************************************************************************/
-#include "ut_tdm.h"
+#include "tc_tdm.h"
/* LCOV_EXCL_START */
}
bool
-ut_tdm_buffer_create(int width, int height, tbm_format format, int flags, bool fill, int count, tbm_surface_h *buffers)
+tc_tdm_buffer_create(int width, int height, tbm_format format, int flags, bool fill, int count, tbm_surface_h *buffers)
{
TDM_UT_GOTO_IF_FAIL(width > 0, failed);
TDM_UT_GOTO_IF_FAIL(height > 0, failed);
}
static void
-_ut_tdm_buffer_destroy_cb(tbm_surface_h buffer, void *user_data)
+_tc_tdm_buffer_destroy_cb(tbm_surface_h buffer, void *user_data)
{
bool *done = (bool*)user_data;
if (done)
TEST_P(TDMBuffer, BufferAddDestroyHandler)
{
bool done = false;
- ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE);
+ ASSERT_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);
TEST_P(TDMBuffer, BufferAddDestroyHandlerTwice)
{
- ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, NULL), TDM_ERROR_BAD_REQUEST);
+ 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);
}
TEST_P(TDMBuffer, BufferAddDestroyHandlerNullObject)
{
- ASSERT_EQ(tdm_buffer_add_destroy_handler(NULL, _ut_tdm_buffer_destroy_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_buffer_add_destroy_handler(NULL, _tc_tdm_buffer_destroy_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMBuffer, BufferAddDestroyHandlerNullOther)
TEST_P(TDMBuffer, BufferRemoveDestroyHandler)
{
bool done = false;
- ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE);
- tdm_buffer_remove_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, &done);
+ ASSERT_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);
TEST_P(TDMBuffer, BufferRemoveDestroyHandlerDifferentData)
{
bool done = false;
- ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE);
- tdm_buffer_remove_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, NULL);
+ ASSERT_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);
TEST_P(TDMBuffer, BufferRemoveDestroyHandlerNullObject)
{
- tdm_buffer_remove_destroy_handler(NULL, _ut_tdm_buffer_destroy_cb, NULL);
+ tdm_buffer_remove_destroy_handler(NULL, _tc_tdm_buffer_destroy_cb, NULL);
}
TEST_P(TDMBuffer, BufferRemoveDestroyHandlerNullOther)
}
static void
-_ut_tdm_buffer_release_cb(tbm_surface_h buffer, void *user_data)
+_tc_tdm_buffer_release_cb(tbm_surface_h buffer, void *user_data)
{
bool *done = (bool*)user_data;
if (done)
TEST_P(TDMBuffer, BufferAddReleaseHandler)
{
bool done = false;
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, &done), TDM_ERROR_NONE);
+ ASSERT_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);
tdm_buffer_unref_backend(buffer);
TEST_P(TDMBuffer, BufferAddReleaseHandlerTwice)
{
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, NULL), TDM_ERROR_BAD_REQUEST);
+ 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);
}
TEST_P(TDMBuffer, BufferAddReleaseHandlerNullObject)
{
bool done = false;
- ASSERT_EQ(tdm_buffer_add_release_handler(NULL, _ut_tdm_buffer_release_cb, &done), TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_buffer_add_release_handler(NULL, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_INVALID_PARAMETER);
ASSERT_EQ(done, false);
}
TEST_P(TDMBuffer, BufferRemoveReleaseHandler)
{
bool done = false;
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, &done), TDM_ERROR_NONE);
+ ASSERT_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);
- tdm_buffer_remove_release_handler(buffer, _ut_tdm_buffer_release_cb, &done);
+ tdm_buffer_remove_release_handler(buffer, _tc_tdm_buffer_release_cb, &done);
tdm_buffer_unref_backend(buffer);
ASSERT_EQ(done, false);
}
TEST_P(TDMBuffer, BufferRemoveReleaseHandlerDifferentData)
{
bool done = false;
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, &done), TDM_ERROR_NONE);
+ ASSERT_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);
- tdm_buffer_remove_release_handler(buffer, _ut_tdm_buffer_release_cb, NULL);
+ tdm_buffer_remove_release_handler(buffer, _tc_tdm_buffer_release_cb, NULL);
tdm_buffer_unref_backend(buffer);
ASSERT_EQ(done, true);
}
static void
-_ut_tdm_buffer_release_cb2(tbm_surface_h buffer, void *user_data)
+_tc_tdm_buffer_release_cb2(tbm_surface_h buffer, void *user_data)
{
bool *done = (bool*)user_data;
if (done)
*done = true;
- tdm_buffer_remove_release_handler(buffer, _ut_tdm_buffer_release_cb2, user_data);
+ tdm_buffer_remove_release_handler(buffer, _tc_tdm_buffer_release_cb2, user_data);
}
TEST_P(TDMBuffer, BufferRemoveReleaseHandlerInHandler)
{
bool done = false;
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE);
+ ASSERT_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);
tdm_buffer_unref_backend(buffer);
ASSERT_EQ(done, true);
done = false;
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE);
+ ASSERT_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);
tdm_buffer_unref_backend(buffer);
ASSERT_EQ(done, true);
done = false;
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE);
+ ASSERT_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);
tdm_buffer_unref_backend(buffer);
TEST_P(TDMBuffer, BufferRemoveReleaseHandlerNullObject)
{
bool done = false;
- ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, &done), TDM_ERROR_NONE);
+ ASSERT_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);
- tdm_buffer_remove_release_handler(NULL, _ut_tdm_buffer_release_cb, &done);
+ tdm_buffer_remove_release_handler(NULL, _tc_tdm_buffer_release_cb, &done);
tdm_buffer_unref_backend(buffer);
ASSERT_EQ(done, true);
}
TEST_P(TDMBuffer, BufferRemoveReleaseHandlerNoAdd)
{
- tdm_buffer_remove_release_handler(buffer, _ut_tdm_buffer_release_cb, NULL);
+ tdm_buffer_remove_release_handler(buffer, _tc_tdm_buffer_release_cb, NULL);
}
#ifdef TDM_UT_TEST_WITH_PARAMS
#include <poll.h>
#include <sys/prctl.h>
-#include "ut_tdm.h"
+#include "tc_tdm.h"
#include "tdm_client.h"
/* LCOV_EXCL_START */
TDM_UT_PIPE_MSG_TERMINATE_SERVER,
};
-static int _ut_tdm_pipe_read_msg(int fd);
-static bool _ut_tdm_pipe_write_msg(int fd, int reply_fd, int msg);
-static pid_t _ut_tdm_client_server_fork(int *pipe_to_parent, int *pipe_to_child);
+static int _tc_tdm_pipe_read_msg(int fd);
+static bool _tc_tdm_pipe_write_msg(int fd, int reply_fd, int msg);
+static pid_t _tc_tdm_client_server_fork(int *pipe_to_parent, int *pipe_to_child);
class TDMClient : public TDMEnv
{
if (server_pid > 0)
return;
- server_pid = _ut_tdm_client_server_fork(pipe_parent, pipe_child);
+ server_pid = _tc_tdm_client_server_fork(pipe_parent, pipe_child);
ASSERT_GT(server_pid, 0);
}
close(pipe_child[0]);
if (pipe_child[1] >= 0) {
if (server_pid > 0) {
- bool ret = _ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_TERMINATE_SERVER);
+ bool ret = _tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_TERMINATE_SERVER);
if (ret) {
if (waitpid(server_pid, NULL, 0) == server_pid)
TDM_INFO("*** server terminated ***");
}
static int
-_ut_tdm_pipe_read_msg(int fd)
+_tc_tdm_pipe_read_msg(int fd)
{
ssize_t len;
int msg;
}
static bool
-_ut_tdm_pipe_write_msg(int fd, int reply_fd, int msg)
+_tc_tdm_pipe_write_msg(int fd, int reply_fd, int msg)
{
ssize_t len = write(fd, &msg, sizeof msg);
TDM_UT_RETURN_FALSE_IF_FAIL(len == sizeof msg);
if (reply_fd >= 0) {
- int reply = _ut_tdm_pipe_read_msg(reply_fd);
+ int reply = _tc_tdm_pipe_read_msg(reply_fd);
TDM_UT_RETURN_FALSE_IF_FAIL(reply == TDM_UT_PIPE_MSG_REPLY);
}
}
static bool
-_ut_tdm_server_set_output_dpms(tdm_display *dpy, int msg)
+_tc_tdm_server_set_output_dpms(tdm_display *dpy, int msg)
{
tdm_error ret;
tdm_output *output;
}
static void
-_ut_tdm_server_run(int *pipe_parent, int *pipe_child)
+_tc_tdm_server_run(int *pipe_parent, int *pipe_child)
{
tdm_display *dpy = NULL;
tdm_error ret;
TDM_UT_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, failed);
TDM_UT_GOTO_IF_FAIL(output != NULL, failed);
- if (!ut_tdm_output_is_connected(output))
+ if (!tc_tdm_output_is_connected(output))
continue;
- TDM_UT_GOTO_IF_FAIL(ut_tdm_output_prepare(dpy, output, true) == true, failed);
+ TDM_UT_GOTO_IF_FAIL(tc_tdm_output_prepare(dpy, output, true) == true, failed);
}
- TDM_UT_GOTO_IF_FAIL(_ut_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_SERVER_READY) == true, done);
+ TDM_UT_GOTO_IF_FAIL(_tc_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_SERVER_READY) == true, done);
TDM_INFO("*** server ready ***");
}
if (fds[0].revents & POLLIN)
- ret = ut_tdm_display_handle_events(dpy);
+ ret = tc_tdm_display_handle_events(dpy);
if (fds[1].revents & POLLIN) {
- int msg = _ut_tdm_pipe_read_msg(pipe_child[0]);
- _ut_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_REPLY);
+ int msg = _tc_tdm_pipe_read_msg(pipe_child[0]);
+ _tc_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_REPLY);
switch (msg) {
case TDM_UT_PIPE_MSG_DPMS_ON:
case TDM_UT_PIPE_MSG_DPMS_OFF:
- _ut_tdm_server_set_output_dpms(dpy, msg);
+ _tc_tdm_server_set_output_dpms(dpy, msg);
break;
case TDM_UT_PIPE_MSG_TERMINATE_SERVER:
goto done;
return;
failed:
- TDM_UT_GOTO_IF_FAIL(_ut_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_SERVER_FAILED) == true, done);
+ TDM_UT_GOTO_IF_FAIL(_tc_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_SERVER_FAILED) == true, done);
TDM_INFO("*** server failed ***");
if (dpy)
}
-static void _ut_tdm_client_sig_handler(int sig)
+static void _tc_tdm_client_sig_handler(int sig)
{
TDM_UT_ERR("got signal: %d", sig);
kill(TDMClient::server_pid, 9);
}
static pid_t
-_ut_tdm_client_server_fork(int *pipe_parent, int *pipe_child)
+_tc_tdm_client_server_fork(int *pipe_parent, int *pipe_child)
{
pid_t pid;
int msg;
TDM_UT_GOTO_IF_FAIL(pipe(pipe_child) == 0, failed);
signal(SIGCHLD, SIG_IGN);
- signal(SIGSEGV, _ut_tdm_client_sig_handler);
+ signal(SIGSEGV, _tc_tdm_client_sig_handler);
prctl(PR_SET_PDEATHSIG, SIGHUP);
TDM_UT_GOTO_IF_FAIL(pid >= 0, failed);
if (pid == 0) {
- _ut_tdm_server_run(pipe_parent, pipe_child);
+ _tc_tdm_server_run(pipe_parent, pipe_child);
close(pipe_child[0]);
close(pipe_child[1]);
close(pipe_parent[0]);
exit(0);
}
- msg = _ut_tdm_pipe_read_msg(pipe_parent[0]);
+ msg = _tc_tdm_pipe_read_msg(pipe_parent[0]);
TDM_UT_GOTO_IF_FAIL(msg == TDM_UT_PIPE_MSG_SERVER_READY, failed);
TDM_INFO("*** server fork done ***");
}
static void
-_ut_tdm_client_vblank_cb(unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data)
+_tc_tdm_client_vblank_cb(unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data)
{
bool *done = (bool *)user_data;
if (done)
ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _ut_tdm_client_vblank_cb, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _tc_tdm_client_vblank_cb, &done), TDM_ERROR_NONE);
ASSERT_EQ(done, false);
while (!done)
ASSERT_EQ(PrepareClient(), true);
- ASSERT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _ut_tdm_client_vblank_cb, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _tc_tdm_client_vblank_cb, &done), TDM_ERROR_NONE);
ASSERT_EQ(done, false);
while (!done)
}
static void
-_ut_tdm_client_output_change_dpms_cb(tdm_client_output *output,
+_tc_tdm_client_output_change_dpms_cb(tdm_client_output *output,
tdm_output_change_type type,
tdm_value value,
void *user_data)
ASSERT_EQ(PrepareClient(), true);
ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE);
- ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), 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);
while (!done)
ASSERT_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);
- ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
+ ASSERT_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);
ASSERT_EQ(PrepareClient(), true);
ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_BAD_REQUEST);
+ 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);
}
TEST_P(TDMClient, ClientOutputAddChangeHandlerNullObject)
{
- ASSERT_EQ(tdm_client_output_add_change_handler(NULL, _ut_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_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);
- ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE);
- tdm_client_output_remove_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL);
+ ASSERT_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);
}
TEST_P(TDMClient, ClientOutputRemoveChangeHandlerDifferentData)
ASSERT_EQ(PrepareClient(), true);
ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE);
- tdm_client_output_remove_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL);
+ ASSERT_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);
}
static void
-_ut_tdm_client_output_change_dpms_cb2(tdm_client_output *output,
+_tc_tdm_client_output_change_dpms_cb2(tdm_client_output *output,
tdm_output_change_type type,
tdm_value value,
void *user_data)
{
switch (type) {
case TDM_OUTPUT_CHANGE_DPMS:
- tdm_client_output_remove_change_handler(output, _ut_tdm_client_output_change_dpms_cb2, user_data);
+ tdm_client_output_remove_change_handler(output, _tc_tdm_client_output_change_dpms_cb2, user_data);
break;
default:
break;
ASSERT_EQ(PrepareClient(), true);
ASSERT_EQ(PrepareOutput(), true);
- ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb2, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), 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);
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);
}
- ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
+ ASSERT_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);
}
TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullObject)
{
- tdm_client_output_remove_change_handler(NULL, _ut_tdm_client_output_change_dpms_cb, NULL);
+ tdm_client_output_remove_change_handler(NULL, _tc_tdm_client_output_change_dpms_cb, NULL);
}
TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullOther)
}
static void
-_ut_tdm_client_vblank_cb2(tdm_client_vblank *vblank,
+_tc_tdm_client_vblank_cb2(tdm_client_vblank *vblank,
tdm_error error,
unsigned int sequence,
unsigned int tv_sec,
ASSERT_EQ(PrepareVblank(), true);
done = false;
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
+ ASSERT_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(PrepareVblank(), true);
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done3), TDM_ERROR_NONE);
+ 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);
start = tdm_helper_get_time();
while (!done1 || !done2 || !done3)
ASSERT_EQ(PrepareOutput(), true);
ASSERT_EQ(PrepareVblank(), true);
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 0, _ut_tdm_client_vblank_cb2, NULL), TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_client_vblank_wait(vblank, 0, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMClient, ClientVblankWaitInterval)
/* start from 1 */
for (int t = 1; t < 10; t++) {
done = false;
- ASSERT_EQ(tdm_client_vblank_wait(vblank, t, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_client_vblank_wait(vblank, t, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
start = tdm_helper_get_time();
while (!done)
}
static void
-_ut_tdm_client_vblank_cb3(tdm_client_vblank *vblank,
+_tc_tdm_client_vblank_cb3(tdm_client_vblank *vblank,
tdm_error error,
unsigned int sequence,
unsigned int tv_sec,
for (int t = 0; t < 10; t++) {
unsigned int cur_seq = 0, temp = 0;
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE);
+ ASSERT_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);
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + 1, _ut_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE);
+ ASSERT_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);
end = tdm_helper_get_time();
for (int t = 1; t < 10; t++) {
unsigned int cur_seq = 0, temp = 0;
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE);
+ ASSERT_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);
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + t, _ut_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE);
+ ASSERT_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);
end = tdm_helper_get_time();
ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 100), TDM_ERROR_NONE);
done = false;
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
start = tdm_helper_get_time();
while (!done)
interval = 1.0 / (double)fps;
done = false;
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
start = tdm_helper_get_time();
while (!done)
for (int v = 0; v < 3; v++) {
cur_seq[v] = 0;
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
}
start = tdm_helper_get_time();
while (cur_seq[0] == 0)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
end = tdm_helper_get_time();
ASSERT_NE(cur_seq[1], 0);
for (int v = 0; v < 3; v++) {
cur_seq[v] = 0;
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
}
while (cur_seq[0] == 0)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
ASSERT_EQ(cur_seq[1], 0);
ASSERT_EQ(cur_seq[2], 0);
while (cur_seq[1] == 0)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
ASSERT_EQ(cur_seq[2], 0);
}
for (int v = 0; v < 3; v++) {
cur_seq[v] = 0;
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
}
start = tdm_helper_get_time();
while (cur_seq[1] == 0)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
end = tdm_helper_get_time();
ASSERT_EQ(cur_seq[0], 0);
ASSERT_LT((end - start), (interval + interval));
while (cur_seq[0] == 0)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
ASSERT_NE(cur_seq[2], 0);
}
{
unsigned int cur_seq = 0;
- ASSERT_EQ(tdm_client_vblank_wait(NULL, 1, _ut_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_client_vblank_wait(NULL, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMClient, ClientVblankWaitNullOther)
ASSERT_EQ(PrepareOutput(), true);
ASSERT_EQ(PrepareVblank(), true);
- ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
+ ASSERT_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);
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, NULL), TDM_ERROR_DPMS_OFF);
+ ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_DPMS_OFF);
- ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
+ ASSERT_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);
}
ASSERT_EQ(PrepareOutput(), true);
ASSERT_EQ(PrepareVblank(), true);
- ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
+ ASSERT_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(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
done = false;
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
+ ASSERT_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);
- ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
+ ASSERT_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);
}
ASSERT_EQ(PrepareVblank(), true);
done = false;
- ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
+ ASSERT_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);
*
**************************************************************************/
-#include "ut_tdm.h"
+#include "tc_tdm.h"
/* LCOV_EXCL_START */
}
tdm_error
-ut_tdm_display_handle_events(tdm_display *dpy)
+tc_tdm_display_handle_events(tdm_display *dpy)
{
struct pollfd fds;
int fd = -1;
}
bool
-ut_tdm_display_has_pp_capability(tdm_display *dpy)
+tc_tdm_display_has_pp_capability(tdm_display *dpy)
{
tdm_display_capability capabilities = (tdm_display_capability)0;
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_display_get_capabilities(dpy, &capabilities) == TDM_ERROR_NONE);
}
bool
-ut_tdm_display_has_capture_capability(tdm_display *dpy)
+tc_tdm_display_has_capture_capability(tdm_display *dpy)
{
tdm_display_capability capabilities = (tdm_display_capability)0;
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_display_get_capabilities(dpy, &capabilities) == TDM_ERROR_NONE);
TEST_P(TDMDisplay, DISABLED_DisplayHandleEvents)
{
/* TODO Generate events*/
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
TEST_P(TDMDisplay, DisplayFlush)
*
**************************************************************************/
-#include "ut_tdm.h"
+#include "tc_tdm.h"
/* LCOV_EXCL_START */
*
**************************************************************************/
-#include "ut_tdm.h"
+#include "tc_tdm.h"
/* LCOV_EXCL_START */
}
static tdm_error
-_ut_tdm_event_loop_fd_cb(int fd, tdm_event_loop_mask mask, void *user_data)
+_tc_tdm_event_loop_fd_cb(int fd, tdm_event_loop_mask mask, void *user_data)
{
bool *done = (bool*)user_data;
if (done)
done = false;
source = tdm_event_loop_add_fd_handler(dpy, pipes[0], TDM_EVENT_LOOP_READABLE,
- _ut_tdm_event_loop_fd_cb, &done, &ret);
+ _tc_tdm_event_loop_fd_cb, &done, &ret);
ASSERT_EQ(ret, TDM_ERROR_NONE);
ASSERT_NE(source, NULL);
//TODO
// while (!done)
-// ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+// ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
tdm_event_loop_source_remove(source);
tdm_error ret;
tdm_event_loop_source *source;
source = tdm_event_loop_add_fd_handler(NULL, 0, TDM_EVENT_LOOP_READABLE,
- _ut_tdm_event_loop_fd_cb, NULL, &ret);
+ _tc_tdm_event_loop_fd_cb, NULL, &ret);
ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
ASSERT_EQ(source, NULL);
}
done = false;
source = tdm_event_loop_add_fd_handler(dpy, pipes[0], TDM_EVENT_LOOP_WRITABLE,
- _ut_tdm_event_loop_fd_cb, &done, &ret);
+ _tc_tdm_event_loop_fd_cb, &done, &ret);
ASSERT_EQ(ret, TDM_ERROR_NONE);
ASSERT_NE(source, NULL);
//TODO
// while (!done)
-// ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+// ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
tdm_event_loop_source_remove(source);
}
static tdm_error
-_ut_tdm_event_loop_timer_cb(void *user_data)
+_tc_tdm_event_loop_timer_cb(void *user_data)
{
bool *done = (bool*)user_data;
if (done)
{
tdm_error ret;
tdm_event_loop_source *source;
- source = tdm_event_loop_add_timer_handler(dpy, _ut_tdm_event_loop_timer_cb, NULL, &ret);
+ 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);
tdm_event_loop_source_remove(source);
{
tdm_error ret;
tdm_event_loop_source *source;
- source = tdm_event_loop_add_timer_handler(NULL, _ut_tdm_event_loop_timer_cb, NULL, &ret);
+ 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);
}
{
tdm_error ret;
tdm_event_loop_source *source;
- source = tdm_event_loop_add_timer_handler(dpy, _ut_tdm_event_loop_timer_cb, NULL, &ret);
+ 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);
//TODO
// while (!done)
-// ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+// ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
tdm_event_loop_source_remove(source);
}
*
**************************************************************************/
-#include "ut_tdm.h"
+#include "tc_tdm.h"
/* LCOV_EXCL_START */
}
static void
-_ut_tdm_helper_capture_cb(tbm_surface_h buffer, void *user_data)
+_tc_tdm_helper_capture_cb(tbm_surface_h buffer, void *user_data)
{
}
ASSERT_EQ(ret, TDM_ERROR_NONE);
ASSERT_NE(output, NULL);
- if (!ut_tdm_output_is_connected(output))
+ if (!tc_tdm_output_is_connected(output))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, output, true), true);
+ ASSERT_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);
ASSERT_EQ(tdm_helper_capture_output(output, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE,
- _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_NONE);
+ _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,
- _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ _tc_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMHelper, HelperCaptureOutputNullOther)
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,
- _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ _tc_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMHelper, HelperGetDisplayInformation)
tdm_output *output = tdm_display_get_output(dpy, o, &ret);
ASSERT_EQ(ret, TDM_ERROR_NONE);
ASSERT_NE(output, NULL);
- if (!ut_tdm_output_is_connected(output))
+ if (!tc_tdm_output_is_connected(output))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, output, true), true);
+ ASSERT_EQ(tc_tdm_output_prepare(dpy, output, true), true);
}
tdm_helper_get_display_information(dpy, reply, &len);
*
**************************************************************************/
-#include "ut_tdm.h"
+#include "tc_tdm.h"
/* LCOV_EXCL_START */
//create HWC_WIN_NUM hwc_windows for each outputs
for (int o = 0; o < output_count; o++) {
- if (ut_tdm_output_is_hwc_enable(outputs[o])) {
+ if (tc_tdm_output_is_hwc_enable(outputs[o])) {
for (int w = 0; w < HWC_WIN_NUM; w++) {
hw = tdm_hwc_create_window(outputs[w], &error);
ASSERT_EQ(TDM_ERROR_NONE, error);
tdm_hwc_window *hw = NULL;
for (int o = 0; o < output_count; o++) {
- if (ut_tdm_output_is_hwc_enable(outputs[o])) {
+ if (tc_tdm_output_is_hwc_enable(outputs[o])) {
hw = tdm_hwc_create_window(outputs[o], &error);
ASSERT_EQ(TDM_ERROR_NONE, error);
error = tdm_hwc_window_destroy(outputs[o], hw);
*
**************************************************************************/
-#include "ut_tdm.h"
+#include "tc_tdm.h"
/* LCOV_EXCL_START */
int old_layer_count = layer_count, count = TDM_UT_INVALID_VALUE;
tdm_error ret;
- if (ut_tdm_output_is_hwc_enable(outputs[o]))
+ if (tc_tdm_output_is_hwc_enable(outputs[o]))
continue;
ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
}
bool
-ut_tdm_layer_is_cursor_layer(tdm_layer *layer)
+tc_tdm_layer_is_cursor_layer(tdm_layer *layer)
{
tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
}
bool
-ut_tdm_layer_is_primary_layer(tdm_layer *layer)
+tc_tdm_layer_is_primary_layer(tdm_layer *layer)
{
tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
}
bool
-ut_tdm_layer_is_video_layer(tdm_layer *layer)
+tc_tdm_layer_is_video_layer(tdm_layer *layer)
{
tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
}
bool
-ut_tdm_layer_support_scale(tdm_layer *layer)
+tc_tdm_layer_support_scale(tdm_layer *layer)
{
tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
}
bool
-ut_tdm_layer_support_no_crop(tdm_layer *layer)
+tc_tdm_layer_support_no_crop(tdm_layer *layer)
{
tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
}
unsigned int
-ut_tdm_layer_get_output_pipe(tdm_layer *layer)
+tc_tdm_layer_get_output_pipe(tdm_layer *layer)
{
unsigned int pipe = (unsigned int)TDM_UT_INVALID_VALUE;
tdm_error ret;
}
tbm_format
-ut_tdm_layer_find_best_format(tdm_layer *layer)
+tc_tdm_layer_find_best_format(tdm_layer *layer)
{
const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
}
bool
-ut_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer_count, bool fill)
+tc_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer_count, bool fill)
{
tdm_error ret;
unsigned int flags = 0;
/* create buffers */
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE);
- format = ut_tdm_layer_find_best_format(layer);
+ format = tc_tdm_layer_find_best_format(layer);
TDM_UT_RETURN_FALSE_IF_FAIL(format != 0);
output = tdm_layer_get_output(layer, &ret);
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE);
TDM_UT_RETURN_FALSE_IF_FAIL(mode != NULL);
- if (ut_tdm_layer_is_primary_layer(layer)) {
+ if (tc_tdm_layer_is_primary_layer(layer)) {
w = mode->hdisplay;
h = mode->vdisplay;
} else {
h = mode->vdisplay / 2;
}
- TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_buffer_create(w, h, format, flags | TBM_BO_SCANOUT, fill, buffer_count, buffers) == true);
+ TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_buffer_create(w, h, format, flags | TBM_BO_SCANOUT, fill, buffer_count, buffers) == true);
TDM_INFO("preparing buffers done");
}
bool
-ut_tdm_layer_prepare_buffer_queue(tdm_layer *layer, tbm_surface_queue_h *buffer_queue)
+tc_tdm_layer_prepare_buffer_queue(tdm_layer *layer, tbm_surface_queue_h *buffer_queue)
{
tdm_error ret;
unsigned int flags = 0;
/* create buffers */
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE);
- format = ut_tdm_layer_find_best_format(layer);
+ format = tc_tdm_layer_find_best_format(layer);
TDM_UT_RETURN_FALSE_IF_FAIL(format != (tbm_format)0);
- if (ut_tdm_layer_is_primary_layer(layer)) {
+ if (tc_tdm_layer_is_primary_layer(layer)) {
tdm_output *output;
const tdm_output_mode *mode = NULL;
output = tdm_layer_get_output(layer, &ret);
}
bool
-ut_tdm_layer_fill_info(tdm_layer *layer, tbm_surface_h buffer, tbm_surface_queue_h buffer_queue, tdm_info_layer *info)
+tc_tdm_layer_fill_info(tdm_layer *layer, tbm_surface_h buffer, tbm_surface_queue_h buffer_queue, tdm_info_layer *info)
{
tdm_error ret;
tdm_output *output;
bh = mode->vdisplay;
w = mode->hdisplay;
h = mode->vdisplay;
- format = ut_tdm_layer_find_best_format(layer);
+ format = tc_tdm_layer_find_best_format(layer);
}
/* TODO: check min,max,prefered size and avaiable formats */
info->src_config.pos.w = w;
info->src_config.pos.h = h;
info->src_config.format = format;
- if (ut_tdm_layer_is_primary_layer(layer)) {
+ if (tc_tdm_layer_is_primary_layer(layer)) {
info->dst_pos.x = 0;
info->dst_pos.y = 0;
} else {
return true;
}
-bool ut_tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
+bool tc_tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
{
tdm_info_layer old_info, info;
TDM_UT_RETURN_FALSE_IF_FAIL(buffer != NULL);
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_info(layer, &old_info) == TDM_ERROR_NONE);
- TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_layer_fill_info(layer, buffer, NULL, &info) == true);
+ TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_fill_info(layer, buffer, NULL, &info) == true);
if (memcmp(&old_info, &info, sizeof info)) {
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE);
return true;
}
-bool ut_tdm_layer_set_buffer_with_pos(tdm_layer *layer, tbm_surface_h buffer, tdm_pos *pos)
+bool tc_tdm_layer_set_buffer_with_pos(tdm_layer *layer, tbm_surface_h buffer, tdm_pos *pos)
{
tdm_info_layer old_info, info;
TDM_UT_RETURN_FALSE_IF_FAIL(pos != NULL);
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_info(layer, &old_info) == TDM_ERROR_NONE);
- TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_layer_fill_info(layer, buffer, NULL, &info) == true);
+ TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_fill_info(layer, buffer, NULL, &info) == true);
info.dst_pos.x = pos->x;
info.dst_pos.y = pos->y;
return true;
}
-bool ut_tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
+bool tc_tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
{
tdm_info_layer old_info, info;
TDM_UT_RETURN_FALSE_IF_FAIL(buffer_queue != NULL);
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_info(layer, &old_info) == TDM_ERROR_NONE);
- TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_layer_fill_info(layer, NULL, buffer_queue, &info) == true);
+ TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_fill_info(layer, NULL, buffer_queue, &info) == true);
if (memcmp(&old_info, &info, sizeof info))
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE);
return true;
}
-bool ut_tdm_layer_is_avaiable(tdm_layer *layer)
+bool tc_tdm_layer_is_avaiable(tdm_layer *layer)
{
tdm_error ret;
tdm_output *output = tdm_layer_get_output(layer, &ret);
TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
/* only check if connected */
- return ut_tdm_output_is_connected(output);
+ return tc_tdm_output_is_connected(output);
}
TEST_P(TDMLayer, LayerGetOutput)
TDM_UT_SKIP_FLAG(has_layers);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
TEST_P(TDMLayer, LayerGetAvailableFormatsNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- if (!ut_tdm_layer_is_avaiable(layers[0]))
+ if (!tc_tdm_layer_is_avaiable(layers[0]))
return;
ASSERT_EQ(tdm_layer_get_available_formats(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TDM_UT_SKIP_FLAG(has_layers);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
ASSERT_NE(check_table, NULL);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
- unsigned int pipe = ut_tdm_layer_get_output_pipe(layers[l]);
+ unsigned int pipe = tc_tdm_layer_get_output_pipe(layers[l]);
int zpos = TDM_UT_INVALID_VALUE;
EXPECT_TRUE(tdm_layer_get_zpos(layers[l], &zpos) == TDM_ERROR_NONE);
EXPECT_TRUE(zpos != TDM_UT_INVALID_VALUE);
- if (ut_tdm_layer_is_video_layer(layers[l]))
+ if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
EXPECT_TRUE(zpos >= 0);
EXPECT_TRUE(pipe < (unsigned int)output_count);
TDM_UT_SKIP_FLAG(has_layers);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
{
TDM_UT_SKIP_FLAG(has_layers);
- ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
+ tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
tdm_info_layer info;
- ASSERT_EQ(ut_tdm_layer_fill_info(layers[l], NULL, NULL, &info), true);
+ 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);
}
}
TDM_UT_SKIP_FLAG(has_layers);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
unsigned int flags = (unsigned int)TDM_UT_INVALID_VALUE;
}
static void
-_ut_tdm_layer_commit_cb(tdm_layer *layer, unsigned int sequence,
+_tc_tdm_layer_commit_cb(tdm_layer *layer, unsigned int sequence,
unsigned int tv_sec, unsigned int tv_usec,
void *user_data)
{
tdm_error ret;
- ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
+ tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
int next_buffer = 0;
- if (ut_tdm_layer_is_cursor_layer(layers[l]))
+ if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_video_layer(layers[l]))
+ if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ ASSERT_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(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _ut_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);
while (displaying_buffer != buffers[next_buffer]) {
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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);
}
tdm_error ret;
- ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
+ tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
int next_buffer = 0;
- if (ut_tdm_layer_is_cursor_layer(layers[l]))
+ if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_video_layer(layers[l]))
+ if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ ASSERT_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(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
if (next_buffer == 3)
next_buffer = 0;
- ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _ut_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);
while (displaying_buffer != buffers[next_buffer]) {
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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);
}
{
TDM_UT_SKIP_FLAG(has_layers);
- ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
+ tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
{
TDM_UT_SKIP_FLAG(has_layers);
- ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
+ tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
int next_buffer = 0;
- if (ut_tdm_layer_is_cursor_layer(layers[l]))
+ if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_video_layer(layers[l]))
+ if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_primary_layer(layers[l]))
+ if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ ASSERT_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(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
if (next_buffer == 3)
next_buffer = 0;
- ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
if (next_buffer == 3)
next_buffer = 0;
}
{
TDM_UT_SKIP_FLAG(has_layers);
- ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
+ tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
int next_buffer = 0;
- if (ut_tdm_layer_is_cursor_layer(layers[l]))
+ if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_video_layer(layers[l]))
+ if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_primary_layer(layers[l]))
+ if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
- ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
+ 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);
ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
{
TDM_UT_SKIP_FLAG(has_layers);
- ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
+ tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
int next_buffer = 0;
- if (ut_tdm_layer_is_cursor_layer(layers[l]))
+ if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_video_layer(layers[l]))
+ if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_primary_layer(layers[l]))
+ if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
- ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _ut_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);
- ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _ut_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);
ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
{
TDM_UT_SKIP_FLAG(has_layers);
- ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
+ tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
int next_buffer = 0;
- if (ut_tdm_layer_is_cursor_layer(layers[l]))
+ if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_video_layer(layers[l]))
+ if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_primary_layer(layers[l]))
+ if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
- ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _ut_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);
- ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _ut_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);
- ASSERT_EQ(ut_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_unset_buffer(layers[l]), TDM_ERROR_NONE);
{
TDM_UT_SKIP_FLAG(has_layers);
- ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
+ tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
int next_buffer = 0;
bool done;
- if (ut_tdm_layer_is_cursor_layer(layers[l]))
+ if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_video_layer(layers[l]))
+ if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_primary_layer(layers[l]))
+ if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
/* set buffer & commit for 10 times */
- ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(ut_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(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
done = false;
- ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
while (!done) {
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
{
TDM_UT_SKIP_FLAG(has_layers);
- ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
+ tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
int next_buffer = 0;
bool done;
- if (ut_tdm_layer_is_cursor_layer(layers[l]))
+ if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_video_layer(layers[l]))
+ if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_primary_layer(layers[l]))
+ if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
/* set buffer & commit for 10 times */
- ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(ut_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(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
done = false;
- ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
while (!done) {
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
- ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
next_buffer = 0;
- ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
+ ASSERT_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);
ASSERT_EQ(ret, TDM_ERROR_NONE);
ASSERT_NE(output, NULL);
- if (!ut_tdm_output_is_connected(output))
+ if (!tc_tdm_output_is_connected(output))
return;
- EXPECT_TRUE(ut_tdm_output_prepare(dpy, output, true) == true);
+ EXPECT_TRUE(tc_tdm_output_prepare(dpy, output, true) == true);
EXPECT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE);
EXPECT_TRUE(tdm_layer_commit(layers[0], NULL, NULL) == TDM_ERROR_DPMS_OFF);
- EXPECT_TRUE(ut_tdm_output_unset(dpy, output) == true);
+ EXPECT_TRUE(tc_tdm_output_unset(dpy, output) == true);
}
TEST_P(TDMLayer, LayerCommitNullObject)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_commit(NULL, _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_layer_commit(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerCommitNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
+ tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
ASSERT_EQ(tdm_layer_commit(layers[0], NULL, NULL), TDM_ERROR_NONE);
}
{
TDM_UT_SKIP_FLAG(has_layers);
- ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
+ tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
tdm_error ret;
ASSERT_EQ(ret, TDM_ERROR_NONE);
ASSERT_NE(output, NULL);
- if (ut_tdm_layer_is_cursor_layer(layers[l]))
+ if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_video_layer(layers[l]))
+ if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_primary_layer(layers[l]))
+ if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true);
+ ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true);
- ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[0]), true);
+ ASSERT_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], _ut_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_remove_commit_handler(layers[l], _ut_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
+ 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);
while (!done1 || done2 || !done3) {
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
{
TDM_UT_SKIP_FLAG(has_layers);
- ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
+ tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
tdm_error ret;
ASSERT_EQ(ret, TDM_ERROR_NONE);
ASSERT_NE(output, NULL);
- if (ut_tdm_layer_is_cursor_layer(layers[l]))
+ if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_video_layer(layers[l]))
+ if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_primary_layer(layers[l]))
+ if (tc_tdm_layer_is_primary_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], _ut_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_remove_commit_handler(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
+ 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);
while (!done1 || !done2 || !done3) {
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
}
static void
-_ut_tdm_layer_commit_cb2(tdm_layer *layer, unsigned int sequence,
+_tc_tdm_layer_commit_cb2(tdm_layer *layer, unsigned int sequence,
unsigned int tv_sec, unsigned int tv_usec,
void *user_data)
{
bool *done = (bool*)user_data;
if (done)
*done = true;
- ASSERT_EQ(tdm_layer_remove_commit_handler(layer, _ut_tdm_layer_commit_cb2, user_data), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_layer_remove_commit_handler(layer, _tc_tdm_layer_commit_cb2, user_data), TDM_ERROR_NONE);
}
TEST_P(TDMLayer, LayerRemoveCommitHandlerInHandler)
{
TDM_UT_SKIP_FLAG(has_layers);
- ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
+ tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
tdm_error ret;
ASSERT_EQ(ret, TDM_ERROR_NONE);
ASSERT_NE(output, NULL);
- if (ut_tdm_layer_is_cursor_layer(layers[l]))
+ if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_video_layer(layers[l]))
+ if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_primary_layer(layers[l]))
+ if (tc_tdm_layer_is_primary_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], _ut_tdm_layer_commit_cb2, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb2, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb2, &done3), TDM_ERROR_NONE);
+ 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);
while (!done1 || !done2 || !done3) {
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_remove_commit_handler(NULL, _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_layer_remove_commit_handler(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerRemoveCommitHandlerNullOther)
tdm_error ret;
- ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
+ tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
for (int l = 0; l < layer_count; l++) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
tbm_surface_h buffer;
tbm_surface_h displaying_buffer;
- if (ut_tdm_layer_is_cursor_layer(layers[l]))
+ if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_video_layer(layers[l]))
+ if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_primary_layer(layers[l]))
+ if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- ASSERT_EQ(ut_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue), true);
+ ASSERT_EQ(tc_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue), true);
ASSERT_NE(buffer_queue, NULL);
- ASSERT_EQ(ut_tdm_layer_set_buffer_queue(layers[l], buffer_queue), true);
+ ASSERT_EQ(tc_tdm_layer_set_buffer_queue(layers[l], buffer_queue), true);
ASSERT_EQ(tdm_layer_commit(layers[l], NULL, NULL), TDM_ERROR_NONE);
displaying_buffer = NULL;
while (displaying_buffer != buffer) {
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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);
}
{
TDM_UT_SKIP_FLAG(has_layers);
- ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
+ tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
for (int l = 0; l < layer_count; l++) {
tbm_surface_queue_h buffer_queue1 = NULL;
tbm_surface_queue_h buffer_queue2 = NULL;
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
- if (ut_tdm_layer_is_cursor_layer(layers[l]))
+ if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
- if (ut_tdm_layer_is_video_layer(layers[l]))
+ if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- EXPECT_TRUE(ut_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue1) == true);
+ EXPECT_TRUE(tc_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue1) == true);
EXPECT_TRUE(buffer_queue1 != NULL);
EXPECT_TRUE(tdm_layer_set_buffer_queue(layers[l], buffer_queue1) == TDM_ERROR_NONE);
- EXPECT_TRUE(ut_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue2) == true);
+ EXPECT_TRUE(tc_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue2) == true);
EXPECT_TRUE(buffer_queue2 != NULL);
EXPECT_TRUE(tdm_layer_set_buffer_queue(layers[l], buffer_queue2) == TDM_ERROR_NONE);
TDM_UT_SKIP_FLAG(has_layers);
for (int l = 0; l < layer_count; ++l) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
- if (!ut_tdm_layer_is_video_layer(layers[l]))
+ if (!tc_tdm_layer_is_video_layer(layers[l]))
continue;
ASSERT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_NONE);
}
TDM_UT_SKIP_FLAG(has_layers);
for (int l = 0; l < layer_count; ++l) {
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
- if (ut_tdm_layer_is_video_layer(layers[l]))
+ if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
ASSERT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_BAD_REQUEST);
tdm_error ret;
tdm_capture *capture;
- if (!ut_tdm_layer_is_avaiable(layers[l]))
+ if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
capture = tdm_layer_create_capture(layers[l], &ret);
*
**************************************************************************/
-#include "ut_tdm.h"
+#include "tc_tdm.h"
/* LCOV_EXCL_START */
tdm_log_enable_dlog(0);
tdm_log_set_debug_level(2);
tdm_log_set_path("/tmp/tdm.log");
- tdm_log_print(TDM_LOG_LEVEL_ERR, "utest\n");
- tdm_log_print(TDM_LOG_LEVEL_WRN, "utest\n");
- tdm_log_print(TDM_LOG_LEVEL_INFO, "utest\n");
- tdm_log_print(TDM_LOG_LEVEL_DBG, "utest\n");
+ tdm_log_print(TDM_LOG_LEVEL_ERR, "haltest\n");
+ tdm_log_print(TDM_LOG_LEVEL_WRN, "haltest\n");
+ tdm_log_print(TDM_LOG_LEVEL_INFO, "haltest\n");
+ tdm_log_print(TDM_LOG_LEVEL_DBG, "haltest\n");
tdm_log_set_path(NULL);
}
tdm_log_enable_color(0);
tdm_log_enable_dlog(1);
tdm_log_set_debug_level(0);
- tdm_log_print(TDM_LOG_LEVEL_ERR, "utest");
- tdm_log_print(TDM_LOG_LEVEL_WRN, "utest");
- tdm_log_print(TDM_LOG_LEVEL_INFO, "utest");
- tdm_log_print(TDM_LOG_LEVEL_DBG, "utest");
+ tdm_log_print(TDM_LOG_LEVEL_ERR, "haltest");
+ tdm_log_print(TDM_LOG_LEVEL_WRN, "haltest");
+ tdm_log_print(TDM_LOG_LEVEL_INFO, "haltest");
+ tdm_log_print(TDM_LOG_LEVEL_DBG, "haltest");
}
TEST(TDMLog, logDlog)
{
tdm_log_enable_dlog(1);
- tdm_log_print(TDM_LOG_LEVEL_ERR, "utest");
- tdm_log_print(TDM_LOG_LEVEL_WRN, "utest");
- tdm_log_print(TDM_LOG_LEVEL_INFO, "utest");
- tdm_log_print(TDM_LOG_LEVEL_DBG, "utest");
+ tdm_log_print(TDM_LOG_LEVEL_ERR, "haltest");
+ tdm_log_print(TDM_LOG_LEVEL_WRN, "haltest");
+ tdm_log_print(TDM_LOG_LEVEL_INFO, "haltest");
+ tdm_log_print(TDM_LOG_LEVEL_DBG, "haltest");
}
TEST(TDMLog, logDlogNormal)
{
tdm_log_enable_dlog(1);
- tdm_log_print(TDM_LOG_LEVEL_ERR, "utest");
- tdm_log_print(TDM_LOG_LEVEL_WRN, "utest");
- tdm_log_print(TDM_LOG_LEVEL_INFO, "utest");
- tdm_log_print(TDM_LOG_LEVEL_DBG, "utest");
+ tdm_log_print(TDM_LOG_LEVEL_ERR, "haltest");
+ tdm_log_print(TDM_LOG_LEVEL_WRN, "haltest");
+ tdm_log_print(TDM_LOG_LEVEL_INFO, "haltest");
+ tdm_log_print(TDM_LOG_LEVEL_DBG, "haltest");
}
TEST(TDMLog, logDlogUnknownLevel)
{
tdm_log_enable_dlog(1);
- tdm_log_print(TDM_UT_INVALID_VALUE, "utest");
+ tdm_log_print(TDM_UT_INVALID_VALUE, "haltest");
}
/* LCOV_EXCL_END */
\ No newline at end of file
*
**************************************************************************/
-#include "ut_tdm.h"
+#include "tc_tdm.h"
/* LCOV_EXCL_START */
*
**************************************************************************/
-#include "ut_tdm.h"
+#include "tc_tdm.h"
/* LCOV_EXCL_START */
-static void _ut_tdm_output_change_cb(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data);
-static void _ut_tdm_output_change_cb2(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data);
+static void _tc_tdm_output_change_cb(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data);
+static void _tc_tdm_output_change_cb2(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data);
TDMOutput::TDMOutput()
{
{
if (outputs) {
for (int o = 0; o < output_count; o++) {
- ASSERT_EQ(ut_tdm_output_unset(dpy, outputs[o]), true);
- tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1);
- tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, &done2);
- tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, &done3);
- tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, NULL);
+ ASSERT_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);
+ tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL);
}
free(outputs);
}
}
bool
-ut_tdm_output_mode_setting(tdm_output *output)
+tc_tdm_output_mode_setting(tdm_output *output)
{
const tdm_output_mode *modes = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
const tdm_output_mode *found = NULL;
}
bool
-ut_tdm_output_is_async_dpms_enable(tdm_output *output)
+tc_tdm_output_is_async_dpms_enable(tdm_output *output)
{
tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE;
if (tdm_output_get_capabilities(output, &capabilities) != TDM_ERROR_NONE)
}
bool
-ut_tdm_output_is_hwc_enable(tdm_output *output)
+tc_tdm_output_is_hwc_enable(tdm_output *output)
{
tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE;
if (tdm_output_get_capabilities(output, &capabilities) != TDM_ERROR_NONE)
}
bool
-ut_tdm_output_is_aod_enable(tdm_output *output)
+tc_tdm_output_is_aod_enable(tdm_output *output)
{
tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE;
if (tdm_output_get_capabilities(output, &capabilities) != TDM_ERROR_NONE)
}
bool
-ut_tdm_output_is_connected(tdm_output *output)
+tc_tdm_output_is_connected(tdm_output *output)
{
tdm_output_conn_status status;
if (tdm_output_get_conn_status(output, &status) != TDM_ERROR_NONE)
}
tdm_layer *
-ut_tdm_output_get_primary_layer(tdm_output *output)
+tc_tdm_output_get_primary_layer(tdm_output *output)
{
tdm_error ret;
tdm_layer *layer;
}
static void
-_ut_tdm_output_done_cb(tdm_output *output, unsigned int sequence,
+_tc_tdm_output_done_cb(tdm_output *output, unsigned int sequence,
unsigned int tv_sec, unsigned int tv_usec,
void *user_data)
{
}
bool
-ut_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill)
+tc_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill)
{
tbm_surface_h buffer = NULL;
tdm_error ret;
bool done = false;
tdm_output_conn_status status;
- TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_output_is_connected(output) == true);
- TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_output_mode_setting(output) == true);
+ TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_output_is_connected(output) == true);
+ TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_output_mode_setting(output) == true);
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE);
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_primary_index(output, &primary_index) == TDM_ERROR_NONE);
TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
TDM_UT_RETURN_FALSE_IF_FAIL(layer != NULL);
- TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_layer_prepare_buffer(layer, &buffer, 1, fill) == true);
+ TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_prepare_buffer(layer, &buffer, 1, fill) == true);
TDM_UT_RETURN_FALSE_IF_FAIL(buffer != NULL);
- TDM_UT_GOTO_IF_FAIL(ut_tdm_layer_set_buffer(layer, buffer) == true, failed);
+ TDM_UT_GOTO_IF_FAIL(tc_tdm_layer_set_buffer(layer, buffer) == true, failed);
if (tdm_helper_output_commit_per_vblank_enabled(output))
TDM_UT_GOTO_IF_FAIL(tdm_layer_commit(layer, NULL, NULL) == TDM_ERROR_NONE, failed);
TDM_UT_GOTO_IF_FAIL(status == TDM_OUTPUT_CONN_STATUS_MODE_SETTED, failed);
while (!done) {
- TDM_UT_GOTO_IF_FAIL(tdm_output_wait_vblank(output, 1, 0, _ut_tdm_output_done_cb, &done) == TDM_ERROR_NONE, failed);
- TDM_UT_GOTO_IF_FAIL(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE, failed);
+ TDM_UT_GOTO_IF_FAIL(tdm_output_wait_vblank(output, 1, 0, _tc_tdm_output_done_cb, &done) == TDM_ERROR_NONE, failed);
+ TDM_UT_GOTO_IF_FAIL(tc_tdm_display_handle_events(dpy) == TDM_ERROR_NONE, failed);
}
tbm_surface_internal_unref(buffer);
}
bool
-ut_tdm_output_prepare_all_output(tdm_display *dpy, tdm_output **outputs, int output_count, bool fill)
+tc_tdm_output_prepare_all_output(tdm_display *dpy, tdm_output **outputs, int output_count, bool fill)
{
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- if (!ut_tdm_output_prepare(dpy, outputs[o], fill))
+ if (!tc_tdm_output_prepare(dpy, outputs[o], fill))
return false;
}
return true;
}
bool
-ut_tdm_output_unset(tdm_display *dpy, tdm_output *output)
+tc_tdm_output_unset(tdm_display *dpy, tdm_output *output)
{
tdm_error ret;
int count = 0;
TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
TDM_UT_RETURN_FALSE_IF_FAIL(layer != NULL);
- if (ut_tdm_layer_is_cursor_layer(layer))
+ if (tc_tdm_layer_is_cursor_layer(layer))
continue;
- if (ut_tdm_layer_is_video_layer(layer))
+ if (tc_tdm_layer_is_video_layer(layer))
continue;
TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE);
/* msec */
double
-ut_tdm_output_get_vblank_interval_time(tdm_output *output)
+tc_tdm_output_get_vblank_interval_time(tdm_output *output)
{
const tdm_output_mode *mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
tdm_error ret = tdm_output_get_mode(output, &mode);
for (int o = 0; o < output_count; o++) {
int count = TDM_UT_INVALID_VALUE;
- if (ut_tdm_output_is_hwc_enable(outputs[o])) {
+ 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);
} else {
tdm_layer *layer;
int layer_count = TDM_UT_INVALID_VALUE;
- if (ut_tdm_output_is_hwc_enable(outputs[o])) {
+ 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);
TDM_UT_SKIP_FLAG(has_outputs);
tdm_layer *layer;
- if (ut_tdm_output_is_hwc_enable(outputs[0])) {
+ if (tc_tdm_output_is_hwc_enable(outputs[0])) {
layer = tdm_output_get_layer(outputs[0], 0, NULL);
ASSERT_EQ(layer, NULL);
} else {
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
int count = TDM_UT_INVALID_VALUE;
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
}
static void
-_ut_tdm_output_change_cb(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data)
+_tc_tdm_output_change_cb(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data)
{
bool *done = (bool *)user_data;
if (done)
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_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);
done1 = false;
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1), 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(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
ASSERT_EQ(done1, true);
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_add_change_handler(outputs[0], _ut_tdm_output_change_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_add_change_handler(outputs[0], _ut_tdm_output_change_cb, NULL), TDM_ERROR_BAD_REQUEST);
+ 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);
}
TEST_P(TDMOutput, OutputAddChangeHandlerNullObject)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_add_change_handler(NULL, _ut_tdm_output_change_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_output_add_change_handler(NULL, _tc_tdm_output_change_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputAddChangeHandlerNullOther)
for (int o = 0; o < output_count; o++) {
for (int t = 0; t < 10; t++) {
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, NULL), TDM_ERROR_NONE);
- tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, NULL);
+ ASSERT_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);
}
}
}
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[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);
done1 = false;
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
- tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, NULL);
+ ASSERT_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);
}
static void
-_ut_tdm_output_change_cb2(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data)
+_tc_tdm_output_change_cb2(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data)
{
bool *done = (bool*)user_data;
if (done)
*done = true;
- tdm_output_remove_change_handler(output, _ut_tdm_output_change_cb2, user_data);
+ tdm_output_remove_change_handler(output, _tc_tdm_output_change_cb2, user_data);
}
TEST_P(TDMOutput, OutputRemoveChangeHandlerInHandler)
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[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);
done1 = false;
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb2, &done1), TDM_ERROR_NONE);
+ 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);
done2 = false;
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done2), TDM_ERROR_NONE);
+ 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);
done3 = false;
- ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb2, &done3), TDM_ERROR_NONE);
+ 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);
}
{
TDM_UT_SKIP_FLAG(has_outputs);
- tdm_output_remove_change_handler(NULL, _ut_tdm_output_change_cb, NULL);
+ tdm_output_remove_change_handler(NULL, _tc_tdm_output_change_cb, NULL);
}
TEST_P(TDMOutput, OutputRemoveChangeHandlerNullOther)
for (int o = 0; o < output_count; o++) {
const tdm_output_mode *modes;
int count;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
ASSERT_EQ(tdm_output_set_mode(outputs[o], NULL), TDM_ERROR_INVALID_PARAMETER);
const tdm_output_mode *modes;
int count;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[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_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);
- if (ut_tdm_output_is_aod_enable(outputs[o])) {
+ if (tc_tdm_output_is_aod_enable(outputs[o])) {
ASSERT_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);
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- if (!ut_tdm_output_is_async_dpms_enable(outputs[o]))
+ if (!tc_tdm_output_is_async_dpms_enable(outputs[o]))
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], _ut_tdm_output_change_cb, &done1), 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);
while (!done1)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
- tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1);
}
}
for (int o = 0; o < output_count; o++) {
tdm_output_dpms dpms_value;
- if (!ut_tdm_output_is_connected(outputs[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_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_ON);
- if (ut_tdm_output_is_aod_enable(outputs[o])) {
+ 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);
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
for (int t = 0; t < 10; t++) {
double start, end, interval;
- interval = ut_tdm_output_get_vblank_interval_time(outputs[o]);
+ interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
done1 = false;
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
while (!done1)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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 */
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_wait_vblank(NULL, 1, 0, _ut_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_output_wait_vblank(NULL, 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputWaitVblankNullOther)
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_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);
}
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _ut_tdm_output_done_cb, NULL), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_NONE);
usleep(1100000);
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
ASSERT_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, _ut_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_output_wait_vblank(outputs[0], 0, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputWaitVblankInterval)
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
/* start from 1 */
for (int t = 1; t < 10; t++) {
double start, end, interval;
- interval = ut_tdm_output_get_vblank_interval_time(outputs[o]);
+ interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
done1 = false;
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
while (!done1)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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 */
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
/* start from 1 */
for (int t = 1; t < 10; t++) {
double start, end, interval;
- interval = ut_tdm_output_get_vblank_interval_time(outputs[o]);
+ interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
+ 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);
start = tdm_helper_get_time();
while (!done1 || !done2 || !done3)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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 */
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], false), true);
+ ASSERT_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, _ut_tdm_output_done_cb, &done), TDM_ERROR_NONE);
+ ASSERT_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);
while (!done)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_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, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
- tdm_output_remove_vblank_handler(outputs[o], _ut_tdm_output_done_cb, &done2);
+ 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);
+ tdm_output_remove_vblank_handler(outputs[o], _tc_tdm_output_done_cb, &done2);
while (!done1 || done2 || !done3)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ut_tdm_output_prepare(dpy, outputs[o], true);
+ tc_tdm_output_prepare(dpy, outputs[o], 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, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
- tdm_output_remove_vblank_handler(outputs[o], _ut_tdm_output_done_cb, NULL);
+ 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);
+ tdm_output_remove_vblank_handler(outputs[o], _tc_tdm_output_done_cb, NULL);
while (!done1 || !done2 || !done3)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
static void
-_ut_tdm_output_done_cb2(tdm_output *output, unsigned int sequence,
+_tc_tdm_output_done_cb2(tdm_output *output, unsigned int sequence,
unsigned int tv_sec, unsigned int tv_usec,
void *user_data)
{
bool *done = (bool*)user_data;
if (done)
*done = true;
- tdm_output_remove_commit_handler(output, _ut_tdm_output_done_cb2, user_data);
+ tdm_output_remove_commit_handler(output, _tc_tdm_output_done_cb2, user_data);
}
TEST_P(TDMOutput, OutputRemoveVblankHandlerInHandler)
TDM_UT_SKIP_FLAG(has_outputs);
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_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, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
+ 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);
while (!done1 || !done2 || !done3)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
continue;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
for (int t = 0; t < 10; t++) {
double start, end, interval;
- interval = ut_tdm_output_get_vblank_interval_time(outputs[o]);
+ interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
done1 = false;
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
while (!done1)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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 */
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_output_commit(NULL, 0, _ut_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_output_commit(NULL, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMOutput, OutputCommitNullOther)
if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
continue;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
continue;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_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);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF);
+ ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF);
}
}
if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
continue;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_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);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF);
+ ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF);
}
}
if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
continue;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- if (!ut_tdm_output_is_aod_enable(outputs[o]))
+ if (!tc_tdm_output_is_aod_enable(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_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);
for (int t = 0; t < 10; t++) {
done1 = false;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
while (!done1)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
tdm_layer *layer;
tdm_error ret;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
ASSERT_EQ(tdm_output_get_primary_index(outputs[o], &index), TDM_ERROR_NONE);
ASSERT_NE(index, TDM_UT_INVALID_VALUE);
if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
continue;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
for (int t = 0; t < 10; t++) {
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
+ 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);
while (!done1 || !done2 || !done3)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
continue;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
for (int t = 0; t < 10; t++) {
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
- tdm_output_remove_commit_handler(outputs[o], _ut_tdm_output_done_cb, &done2);
+ 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);
+ tdm_output_remove_commit_handler(outputs[o], _tc_tdm_output_done_cb, &done2);
while (!done1 || done2 || !done3)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
continue;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
for (int t = 0; t < 10; t++) {
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
- tdm_output_remove_commit_handler(outputs[o], _ut_tdm_output_done_cb, NULL);
+ 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);
+ tdm_output_remove_commit_handler(outputs[o], _tc_tdm_output_done_cb, NULL);
while (!done1 || !done2 || !done3)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
continue;
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
+ ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
for (int t = 0; t < 10; t++) {
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb2, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb2, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb2, &done3), TDM_ERROR_NONE);
+ 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);
while (!done1 || !done2 || !done3)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
}
*
**************************************************************************/
-#include "ut_tdm.h"
+#include "tc_tdm.h"
/* LCOV_EXCL_START */
tdm_hwc_window * hw = NULL;
for (int o = 0; o < output_count; o++) {
- if (ut_tdm_output_is_hwc_enable(outputs[o])) {
+ if (tc_tdm_output_is_hwc_enable(outputs[o])) {
hw = tdm_hwc_create_window(hwc[o], &error);
ASSERT_EQ(TDM_ERROR_NONE, error);
tdm_hwc_window_destroy(hw);
for (int o = 0; o < output_count; o++) {
tbm_surface_h target_buff = CreateBufferForOutput(i);
ASSERT_NE(NULL, target_buff);
- if (ut_tdm_output_is_hwc_enable(outputs[o])) {
+ if (tc_tdm_output_is_hwc_enable(outputs[o])) {
error = tdm_hwc_set_client_target_buffer(outputs[o], target_buff, damage,
NULL, 0);
tbm_surface_internal_destroy(target_buff);
tdm_region damage = {.num_rects = 0, .rects = NULL};
for (int o = 0; o < output_count; o++) {
- if (ut_tdm_output_is_hwc_enable(outputs[o])) {
+ if (tc_tdm_output_is_hwc_enable(outputs[o])) {
error = tdm_hwc_set_client_target_buffer(outputs[o], NULL, damage,
NULL, 0);
ASSERT_EQ(TDM_ERROR_NONE, error);
tbm_surface_queue_h queue = NULL;
for (int o = 0; o < output_count; o++) {
- if (ut_tdm_output_is_hwc_enable(outputs[o])) {
+ if (tc_tdm_output_is_hwc_enable(outputs[o])) {
queue = tdm_hwc_get_client_target_buffer_queue(outputs[o], &error);
tbm_surface_queue_destroy(queue);
ASSERT_EQ(TDM_ERROR_NONE, error);
uint32_t num_types;
for (int o = 0; o < output_count; o++) {
- if (ut_tdm_output_is_hwc_enable(outputs[o])) {
+ if (tc_tdm_output_is_hwc_enable(outputs[o])) {
error = tdm_hwc_validate(outputs[o], &num_types);
ASSERT_EQ(TDM_ERROR_NONE, error);
} else {
for (int i = 0; i < output_count; i++) {
- if (ut_tdm_output_is_hwc_enable(outputs[o])) {
+ if (tc_tdm_output_is_hwc_enable(outputs[o])) {
error = tdm_hwc_validate(outputs[o], &validate_num);
ASSERT_EQ(TDM_ERROR_NONE, error);
}
for (int i = 0; i < output_count; i++) {
- if (ut_tdm_output_is_hwc_enable(outputs[o])) {
+ if (tc_tdm_output_is_hwc_enable(outputs[o])) {
error = tdm_hwc_validate(outputs[o], &validate_num);
ASSERT_EQ(TDM_ERROR_NONE, error);
int count;
for (int o = 0; o < output_count; o++) {
- if (ut_tdm_output_is_hwc_enable(outputs[o])) {
+ if (tc_tdm_output_is_hwc_enable(outputs[o])) {
error = tdm_hwc_get_supported_formats(outputs[o], &formats, &count);
if (error != TDM_ERROR_NOT_IMPLEMENTED) {
ASSERT_EQ(TDM_ERROR_NONE, error);
*
**************************************************************************/
-#include "ut_tdm.h"
+#include "tc_tdm.h"
/* LCOV_EXCL_START */
-static void _ut_tdm_vblank_create_cb(tdm_vblank *vblank, void *user_data);
-static void _ut_tdm_vblank_create_cb2(tdm_vblank *vblank, void *user_data);
+static void _tc_tdm_vblank_create_cb(tdm_vblank *vblank, void *user_data);
+static void _tc_tdm_vblank_create_cb2(tdm_vblank *vblank, void *user_data);
class TDMVblank : public TDMOutput
{
void TDMVblank::TearDown(void)
{
- tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this);
- tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL);
- tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb2, this);
- tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb2, NULL);
+ tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this);
+ tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL);
+ tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb2, this);
+ tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb2, NULL);
TestDestroyVblanks();
vblank_count = 0;
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
vblank_count = 3;
bool TDMVblank::TestPrepareOutput(void)
{
for (int o = 0; o < output_count; o++) {
- if (!ut_tdm_output_is_connected(outputs[o]))
+ if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_output_prepare(dpy, outputs[o], false) == true);
+ TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_output_prepare(dpy, outputs[o], false) == true);
}
return true;
}
-bool ut_tdm_vblank_is_avaiable(tdm_vblank *vblank)
+bool tc_tdm_vblank_is_avaiable(tdm_vblank *vblank)
{
tdm_error ret;
tdm_output *output = tdm_vblank_get_output(vblank, &ret);
TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
/* only check if connected */
- return ut_tdm_output_is_connected(output);
+ return tc_tdm_output_is_connected(output);
}
/* tdm_vblank_set_client_vblank_fps */
TEST_P(TDMVblank, DISABLED_VblankSetClientVblankFps)
{
- /* tested in ut_tdm_client.c */
+ /* tested in tc_tdm_client.c */
}
TEST_P(TDMVblank, VblankSetClientVblankFpsNullObject)
/* tdm_vblank_set_client_vblank_fps */
TEST_P(TDMVblank, DISABLED_VblankSetClientIgnoreGlobalFps)
{
- /* tested in ut_tdm_client.c */
+ /* tested in tc_tdm_client.c */
}
TEST_P(TDMVblank, VblankSetClientIgnoreGlobalFpsNullObject)
}
static void
-_ut_tdm_vblank_create_cb(tdm_vblank *vblank, void *user_data)
+_tc_tdm_vblank_create_cb(tdm_vblank *vblank, void *user_data)
{
TDMVblank *test_vblank = (TDMVblank*)user_data;
if (test_vblank)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
+ ASSERT_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;
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL), TDM_ERROR_BAD_REQUEST);
+ 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);
}
TEST_P(TDMVblank, VblankAddCreateHandlerNullObject)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_vblank_add_create_handler(NULL, _ut_tdm_vblank_create_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_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, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
- tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this);
+ ASSERT_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++) {
tdm_error ret;
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
- tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this);
- tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this);
- tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this);
+ tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this);
+ tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this);
+ tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this);
for (int o = 0; o < output_count; o++) {
tdm_error ret;
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
- tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL);
+ tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL);
for (int o = 0; o < output_count; o++) {
tdm_error ret;
}
static void
-_ut_tdm_vblank_create_cb2(tdm_vblank *vblank, void *user_data)
+_tc_tdm_vblank_create_cb2(tdm_vblank *vblank, void *user_data)
{
TDMVblank *test_vblank = (TDMVblank*)user_data;
test_vblank->done = true;
- tdm_vblank_remove_create_handler(test_vblank->dpy, _ut_tdm_vblank_create_cb2, user_data);
+ tdm_vblank_remove_create_handler(test_vblank->dpy, _tc_tdm_vblank_create_cb2, user_data);
}
TEST_P(TDMVblank, VblankRemoveCreateHandlerInHandler)
{
TDM_UT_SKIP_FLAG(has_outputs);
- ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb2, this), TDM_ERROR_NONE);
+ ASSERT_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;
{
TDM_UT_SKIP_FLAG(has_outputs);
- tdm_vblank_remove_create_handler(NULL, _ut_tdm_vblank_create_cb, NULL);
+ tdm_vblank_remove_create_handler(NULL, _tc_tdm_vblank_create_cb, NULL);
}
TEST_P(TDMVblank, VblankRemoveCreateHandlerNullOther)
const tdm_output_mode *mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
tdm_error ret;
- if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
+ if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
continue;
ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
}
static void
-_ut_tdm_vblank_cb(tdm_vblank *vblank, tdm_error error, unsigned int sequence,
+_tc_tdm_vblank_cb(tdm_vblank *vblank, tdm_error error, unsigned int sequence,
unsigned int tv_sec, unsigned int tv_usec, void *user_data)
{
unsigned int *cur_seq = (unsigned int *)user_data;
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
double start, end, interval;
- if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
+ if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
continue;
ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
unsigned int cur_seq = 0;
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
while (cur_seq == 0)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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 */
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
double start, end, interval;
- if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
+ if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
continue;
ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
cur_seq = seq1 = seq2 = 0;
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &seq1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &seq2), TDM_ERROR_NONE);
+ 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);
while (cur_seq == 0)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
end = tdm_helper_get_time();
ASSERT_NE(seq1, 0);
ASSERT_EQ(TestPrepareOutput(), true);
ASSERT_EQ(TestCreateVblanks(), true);
- ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, _ut_tdm_vblank_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, _tc_tdm_vblank_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMVblank, VblankWaitInterval)
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
double start, end, interval;
- if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
+ if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
continue;
ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
unsigned int cur_seq = 0;
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, t, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, t, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
while (cur_seq == 0)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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 */
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
double start, end, interval;
- if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
+ if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
continue;
ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
for (int t = 0; t < 10; t++) {
unsigned int cur_seq = 0, temp = 0;
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
while (cur_seq == 0)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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, _ut_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
+ ASSERT_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(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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 */
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
double start, end, interval;
- if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
+ if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
continue;
ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
for (int t = 1; t < 10; t++) {
unsigned int cur_seq = 0, temp = 0;
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
while (cur_seq == 0)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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, _ut_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
+ ASSERT_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(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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 */
unsigned int cur_seq = 0;
- ASSERT_EQ(tdm_vblank_wait(NULL, 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_INVALID_PARAMETER);
+ ASSERT_EQ(tdm_vblank_wait(NULL, 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMVblank, VblankWaitNullOther)
tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
ASSERT_EQ(ret, TDM_ERROR_NONE);
- if (!ut_tdm_output_is_connected(output))
+ if (!tc_tdm_output_is_connected(output))
continue;
ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_DPMS_OFF);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_DPMS_OFF);
}
}
tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
ASSERT_EQ(ret, TDM_ERROR_NONE);
- if (!ut_tdm_output_is_connected(output))
+ if (!tc_tdm_output_is_connected(output))
continue;
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
while (temp == 0)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
ASSERT_EQ(ret, TDM_ERROR_NONE);
- if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
+ if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
continue;
- if (!ut_tdm_output_is_connected(output))
+ if (!tc_tdm_output_is_connected(output))
continue;
ASSERT_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);
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_NONE);
}
}
tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
ASSERT_EQ(ret, TDM_ERROR_NONE);
- if (ut_tdm_output_is_connected(output))
+ if (tc_tdm_output_is_connected(output))
continue;
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_OUTPUT_DISCONNECTED);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_OUTPUT_DISCONNECTED);
}
}
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
double start, end, interval;
- if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
+ if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
continue;
ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 100), TDM_ERROR_NONE);
unsigned int cur_seq = 0;
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
while (cur_seq == 0)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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 */
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
double start, end, interval, vrefresh_interval;
- if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
+ if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
continue;
ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
unsigned int cur_seq = 0;
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
while (cur_seq == 0)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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 */
unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
double start, end, interval;
- if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
+ if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
continue;
ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
unsigned int cur_seq = 0;
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
while (cur_seq == 0)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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_EQ(TestCreateVblanks3(), true);
ASSERT_EQ(vblank_count, 3);
- if (!ut_tdm_vblank_is_avaiable(vblanks[0]))
+ if (!tc_tdm_vblank_is_avaiable(vblanks[0]))
return;
ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE);
for (int v = 0; v < 3; v++) {
cur_seq[v] = 0;
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
}
start = tdm_helper_get_time();
while (cur_seq[2] == 0)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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_EQ(cur_seq[0], 0);
while (cur_seq[1] == 0)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
ASSERT_EQ(cur_seq[0], 0);
while (cur_seq[0] == 0)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_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, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
+ ASSERT_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(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
ASSERT_EQ(cur_seq[1], 0);
ASSERT_EQ(cur_seq[0], 0);
while (cur_seq[1] == 0)
- ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
ASSERT_EQ(cur_seq[0], 0);
}
tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
ASSERT_EQ(ret, TDM_ERROR_NONE);
- if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
+ if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
continue;
- if (ut_tdm_output_is_connected(output))
+ if (tc_tdm_output_is_connected(output))
continue;
ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_DPMS_OFF);
- ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_NONE);
+ ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_NONE);
}
}
tdm_vblank *vblank = vblanks[0];
unsigned int cur_seq = 0;
- ASSERT_EQ(tdm_vblank_wait(vblank, 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
+ ASSERT_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(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
}
}
-%define UTEST_PACKAGE 1
-%define UTEST_GCOV 0
+%define HALTESTS_PACKAGE 1
+%define HALTESTS_GCOV 0
Name: libtdm
Version: 1.18.0
%description client-devel
Tizen Display Manager Client Library headers
-%if "%{UTEST_PACKAGE}" == "1"
+%if "%{HALTESTS_PACKAGE}" == "1"
%package haltests
Summary: Tizen Display Manager unit tests package
Group: Development/Libraries
cp %{SOURCE1001} .
%build
-UTEST="no"
+HALTESTS="no"
-%if "%{UTEST_PACKAGE}" == "1"
-UTEST="yes"
+%if "%{HALTESTS_PACKAGE}" == "1"
+HALTESTS="yes"
%endif
-%if "%{UTEST_GCOV}" == "1"
+%if "%{HALTESTS_GCOV}" == "1"
CFLAGS+=" -fprofile-arcs -ftest-coverage -DTIZEN_TEST_GCOV"
CXXFLAGS+=" -fprofile-arcs -ftest-coverage -DTIZEN_TEST_GCOV"
LDFLAGS+=" -lgcov"
%endif
-%reconfigure --disable-static --with-utests=${UTEST} \
+%reconfigure --disable-static --with-haltests=${HALTESTS} \
--with-tdm-data-path=%{TZ_SYS_RO_SHARE}/tdm \
CFLAGS="${CFLAGS} -Wall -Werror" \
CXXFLAGS="${CXXFLAGS} -Wall -Werror" \
%attr(750,root,root) %{_bindir}/tdm-test-server
%{_bindir}/tdm-test-client
-%if "%{UTEST_PACKAGE}" == "1"
+%if "%{HALTESTS_PACKAGE}" == "1"
%files haltests
%defattr(-,root,root,-)
-%{_bindir}/tdm-utests
+%{_bindir}/tdm-haltests
%endif
%changelog
+++ /dev/null
-bin_PROGRAMS = tdm-utests
-
-tdm_utests_SOURCES = \
- src/ut_tdm_main.cpp \
- src/ut_tdm_log.cpp \
- src/ut_tdm_env.cpp \
- src/ut_tdm_event_loop.cpp \
- src/ut_tdm_buffer.cpp \
- src/ut_tdm_helper.cpp \
- src/ut_tdm_vblank.cpp \
- src/ut_tdm_display.cpp \
- src/ut_tdm_output.cpp \
- src/ut_tdm_layer.cpp \
- src/ut_tdm_client.cpp \
- src/ut_tdm_backend_env.cpp \
- src/ut_tdm_backend_display.cpp \
- src/ut_tdm_backend_pp.cpp \
- src/ut_tdm_backend_capture.cpp
-
-tdm_utests_SOURCES += \
- ../tools/buffers.c
-
-tdm_utests_CXXFLAGS = \
- $(CXXFLAGS) \
- $(TDM_CFLAGS) \
- -I../src \
- -I../include \
- -I../client \
- -I../tools \
- -I$(includedir)/gtest \
- -fpermissive
-# The flag -w is used, because there are many warnings in libtdm's sources.
-# Warnings occur because we build project with g++.
-# In C++ we need to use explicit types conversion.
-
-tdm_utests_LDFLAGS = \
- ${LDFLAGS} \
- $(TDM_LIBS) \
- $(top_builddir)/src/libtdm.la \
- $(top_builddir)/client/libtdm-client.la \
- $(top_builddir)/common/libtdm-common.la \
- -lgtest
-
-check:
- ./tdm-utests
projects / platform / core / uifw / libtdm.git / commitdiff