stubs/tdm_log.cpp \
stubs/tdm_thread.cpp \
stubs/tdm_server.cpp \
- stubs/tdm_vblank.cpp
+ stubs/tdm_vblank.cpp \
+ stubs/pthread_stubs.cpp \
+ stubs/stdlib_stubs.cpp
tdm_utests_CXXFLAGS = \
$(CXXFLAGS) \
-I./gtest/googletest/include \
-fpermissive \
-w
+# 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_LDADD = \
gtest/googletest/lib/.libs/libgtest.a
_init_test();
- dpy = calloc(1, sizeof(tdm_private_display));
+ dpy = (tdm_private_display *)calloc(1, sizeof(tdm_private_display));
g_private_display = dpy;
dpy->init_count = 3;
PTHREAD_MUTEX_INIT_ERROR = 1;
- actual = tdm_display_init(NULL);
+ actual = (tdm_private_display *)tdm_display_init(NULL);
expected = NULL;
CALLOC_ERROR = 1;
- actual = tdm_display_init(NULL);
+ actual = (tdm_private_display *)tdm_display_init(NULL);
ASSERT_EQ(actual, expected);
}
g_private_display = &ut_private_display;
- actual = tdm_display_init(NULL);
+ actual = (tdm_private_display *)tdm_display_init(NULL);
ASSERT_TRUE(actual == expected);
}
#include "tdm_buffer.c"
-void tdm_buffer_release_handler_f(tbm_surface_h buffer, void *user_data) {}
+void tdm_buffer_release_handler_f(tbm_surface_h buffer, void *user_data)
+{
+ (void)buffer;
+ (void)user_data;
+}
static void _init_test()
{
TEST(tdm_capture_attach, null_ptr_fail_2)
{
- struct _tbm_surface buffer;
tdm_error error = TDM_ERROR_NONE;
struct _tdm_private_capture capture;
tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
CALLOC_ERROR = 0;
CALLOC_RETURN_BUFFER = 0;
FREE_CALLED = 0;
- DISPLAY_GET_FD_ERROR = 0;
TDM_PP_CREATE_INTERNAL_ERROR = 0;
OUTPUT_SET_PROPERTY_ERROR = 0;
OUTPUT_GET_PROPERTY_ERROR = 0;
tdm_private_layer layer;
tdm_private_output private_output;
layer.private_output = &private_output;
- unsigned int zpos;
- unsigned int expected_zpos = 547;
+ int zpos;
+ int expected_zpos = 547;
_init_test();
{
tdm_error error = TDM_ERROR_NONE;
tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
- unsigned int zpos;
+ int zpos;
_init_test();
{
tdm_error error = TDM_ERROR_INVALID_PARAMETER;
tdm_error expected_error = TDM_ERROR_NONE;
- tdm_output_dpms dpms_value;
+ tdm_output_dpms dpms_value = TDM_OUTPUT_DPMS_OFF;
tdm_private_output output;
tdm_private_display private_display;
{
tdm_error error = TDM_ERROR_NONE;
tdm_error not_expected_error = TDM_ERROR_NONE;
- tdm_output_dpms dpms_value;
+ tdm_output_dpms dpms_value = TDM_OUTPUT_DPMS_ON;
tdm_private_output output;
tdm_private_display private_display;
{
tdm_error error = TDM_ERROR_NONE;
tdm_error expected_error = TDM_ERROR_NONE;
- tdm_output_dpms dpms_value;
+ tdm_output_dpms dpms_value = TDM_OUTPUT_DPMS_OFF;
tdm_private_output output;
tdm_private_display private_display;
{
tdm_error error = TDM_ERROR_NONE;
tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
- tdm_output_dpms dpms_value;
+ tdm_output_dpms dpms_value = TDM_OUTPUT_DPMS_OFF;
_init_test();
/* HELPER FUNCTIONS */
tdm_error ut_tdm_event_loop_fd_handler(int fd, tdm_event_loop_mask mask,
- void *user_data) { }
+ void *user_data)
+{
+ (void)fd;
+ (void)mask;
+ (void)user_data;
+
+ return TDM_ERROR_NONE;
+}
-tdm_error ut_tdm_event_loop_timer_handler(void *user_data) { }
+tdm_error ut_tdm_event_loop_timer_handler(void *user_data)
+{
+ (void)user_data;
+
+ return TDM_ERROR_NONE;
+}
/* UNIT TESTS */
private_loop.wl_loop = &wl_loop;
timer_source =
- tdm_event_loop_add_timer_handler(&dpy,
+ (tdm_event_loop_source_timer *)tdm_event_loop_add_timer_handler(&dpy,
ut_tdm_event_loop_timer_handler,
NULL, &error);
{
tdm_error error = TDM_ERROR_OPERATION_FAILED;
tdm_error expected_error = TDM_ERROR_NONE;
- tdm_event_loop_mask mask;
+ tdm_event_loop_mask mask = TDM_EVENT_LOOP_READABLE;
tdm_event_loop_source_fd source;
_init_test();
{
tdm_error error = TDM_ERROR_NONE;
tdm_error expected_error = TDM_ERROR_OPERATION_FAILED;
- tdm_event_loop_mask mask;
+ tdm_event_loop_mask mask = TDM_EVENT_LOOP_READABLE;
tdm_event_loop_source_fd source;
_init_test();
{
tdm_error error = TDM_ERROR_NONE;
tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
- tdm_event_loop_mask mask;
+ tdm_event_loop_mask mask = TDM_EVENT_LOOP_READABLE;
_init_test();
{
tdm_error error = TDM_ERROR_INVALID_PARAMETER;
tdm_error expected_error = TDM_ERROR_NONE;
- tdm_event_loop_mask mask;
+ tdm_event_loop_mask mask = TDM_EVENT_LOOP_READABLE;
tdm_private_display dpy;
tdm_private_loop private_loop;
struct wl_event_loop wl_loop;
private_loop.wl_loop = &wl_loop;
fd_source =
- tdm_event_loop_add_fd_handler(&dpy, 5, mask,
- ut_tdm_event_loop_fd_handler,
- NULL, &error);
+ (tdm_event_loop_source_fd *)tdm_event_loop_add_fd_handler(&dpy, 5, mask,
+ ut_tdm_event_loop_fd_handler,
+ NULL, &error);
free(fd_source);
ASSERT_EQ(error, expected_error);
{
tdm_error error = TDM_ERROR_NONE;
tdm_error expected_error = TDM_ERROR_OUT_OF_MEMORY;
- tdm_event_loop_mask mask;
+ tdm_event_loop_mask mask = TDM_EVENT_LOOP_READABLE;
tdm_private_display dpy;
tdm_private_loop private_loop;
struct wl_event_loop wl_loop;
{
tdm_error error = TDM_ERROR_NONE;
tdm_error expected_error = TDM_ERROR_OUT_OF_MEMORY;
- tdm_event_loop_mask mask;
+ tdm_event_loop_mask mask = TDM_EVENT_LOOP_READABLE;
tdm_private_display dpy;
tdm_private_loop private_loop;
struct wl_event_loop wl_loop;
{
tdm_error error = TDM_ERROR_NONE;
tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
- tdm_event_loop_mask mask;
+ tdm_event_loop_mask mask = TDM_EVENT_LOOP_READABLE;
tdm_private_display dpy;
tdm_private_loop private_loop;
{
tdm_error error = TDM_ERROR_NONE;
tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
- tdm_event_loop_mask mask;
+ tdm_event_loop_mask mask = TDM_EVENT_LOOP_READABLE;
tdm_private_display dpy;
_init_test();
{
tdm_error error = TDM_ERROR_NONE;
tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
- tdm_event_loop_mask mask;
+ tdm_event_loop_mask mask = TDM_EVENT_LOOP_READABLE;
tdm_private_display dpy;
_init_test();
{
tdm_error error = TDM_ERROR_NONE;
tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
- tdm_event_loop_mask mask;
+ tdm_event_loop_mask mask = TDM_EVENT_LOOP_READABLE;
tdm_private_display dpy;
_init_test();
{
tdm_error error = TDM_ERROR_NONE;
tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
- tdm_event_loop_mask mask;
+ tdm_event_loop_mask mask = TDM_EVENT_LOOP_READABLE;
_init_test();
#define free ut_free
#define pthread_mutex_init ut_pthread_mutex_init
#define pthread_mutex_unlock ut_pthread_mutex_unlock
-#define tdm_buffer_get_info ut_tdm_buffer_get_info
-#define tdm_buffer_list_dump ut_tdm_buffer_list_dump
#define tdm_buffer_ref_backend ut_tdm_buffer_ref_backend
#include "tdm_pp.c"
--- /dev/null
+#include <pthread.h>
+
+int PTHREAD_MUTEX_INIT_ERROR;
+
+int ut_pthread_mutex_lock(pthread_mutex_t * __mutex)
+{
+ (void)__mutex;
+
+ return 0;
+}
+
+int ut_pthread_mutex_unlock(pthread_mutex_t * __mutex)
+{
+ (void)__mutex;
+
+ return 0;
+}
+
+int ut_pthread_mutex_init(pthread_mutex_t * __mutex,
+ const pthread_mutexattr_t * __mutexattr)
+{
+ (void)__mutex;
+ (void)__mutexattr;
+
+ if (PTHREAD_MUTEX_INIT_ERROR) {
+ return PTHREAD_MUTEX_INIT_ERROR;
+ }
+
+ return 0;
+}
#include <pthread.h>
#include <stdio.h>
-static int PTHREAD_MUTEX_INIT_ERROR;
+extern int PTHREAD_MUTEX_INIT_ERROR;
-static int ut_pthread_mutex_lock(pthread_mutex_t * __mutex) { }
+int ut_pthread_mutex_lock(pthread_mutex_t * __mutex);
-static int ut_pthread_mutex_unlock(pthread_mutex_t * __mutex) { }
+int ut_pthread_mutex_unlock(pthread_mutex_t * __mutex);
-static int ut_pthread_mutex_init(pthread_mutex_t * __mutex,
- const pthread_mutexattr_t * __mutexattr)
-{
- if (PTHREAD_MUTEX_INIT_ERROR) {
- return PTHREAD_MUTEX_INIT_ERROR;
- }
-
- return 0;
-}
+int ut_pthread_mutex_init(pthread_mutex_t * __mutex,
+ const pthread_mutexattr_t * __mutexattr);
#endif /* _PTHREAD_STUBS_H */
--- /dev/null
+#include "stdlib_stubs.h"
+
+int CALLOC_ERROR;
+int CALLOC_RETURN_BUFFER;
+int FREE_CALLED;
+
+tdm_buffer_info buffer;
+
+void *ut_calloc(size_t nmemb, size_t size)
+{
+ if (CALLOC_ERROR) {
+ return NULL;
+ }
+
+ if (CALLOC_RETURN_BUFFER) {
+ return &buffer;
+ }
+
+ return calloc(nmemb, size);
+}
+
+void ut_free(void *ptr)
+{
+ FREE_CALLED = 1;
+ free(ptr);
+}
#include "tdm.h"
#include "tdm_private.h"
-static int CALLOC_ERROR;
-static int CALLOC_RETURN_BUFFER;
-static int FREE_CALLED;
+extern int CALLOC_ERROR;
+extern int CALLOC_RETURN_BUFFER;
+extern int FREE_CALLED;
-static tdm_buffer_info buffer;
+extern tdm_buffer_info buffer;
-static void *ut_calloc(size_t nmemb, size_t size)
-{
- if (CALLOC_ERROR) {
- return NULL;
- }
+void *ut_calloc(size_t nmemb, size_t size);
- if (CALLOC_RETURN_BUFFER) {
- return &buffer;
- }
-
- return calloc(nmemb, size);
-}
-
-static void ut_free(void *ptr)
-{
- FREE_CALLED = 1;
- free(ptr);
-}
+void ut_free(void *ptr);
#endif /* _STDLIB_STUBS_H */
tbm_bufmgr tbm_bufmgr_init(int fd)
{
+ (void)fd;
+ return NULL;
}
void tbm_bufmgr_deinit(tbm_bufmgr bufmgr)
{
+ (void)bufmgr;
+
TBM_BUFMGR_DEINIT_CALLED = 1;
}
tbm_bo tbm_surface_internal_get_bo(tbm_surface_h surface, int bo_idx)
{
+ (void)surface;
+ (void)bo_idx;
+
if (!surface) {
return NULL;
}
+
+ return NULL;
}
int tbm_bo_get_user_data(tbm_bo bo, unsigned long key, void **data)
{
+ (void)bo;
+ (void)key;
+ (void)data;
+
if (TBM_BO_GET_USER_DATA_NULL) {
*data = NULL;
return;
}
- *data = "data";
+ *data = (void *)"data";
+
+ return 0;
}
int tbm_bo_add_user_data(tbm_bo bo, unsigned long key,
tbm_data_free data_free_func)
{
+ (void)bo;
+ (void)key;
+ (void)data_free_func;
+
+ return 0;
}
int tbm_bo_set_user_data(tbm_bo bo, unsigned long key, void *data)
{
+ (void)bo;
+ (void)key;
+ (void)data;
+
+ return 0;
}
void tbm_surface_internal_ref(tbm_surface_h surface)
{
+ (void)surface;
}
void tbm_surface_internal_unref(tbm_surface_h surface)
{
+ (void)surface;
}
tbm_surface_queue_error_e tbm_surface_queue_acquire(
tbm_surface_queue_h surface_queue, tbm_surface_h *surface)
{
+ (void)surface_queue;
+ (void)surface;
+
+ return TBM_SURFACE_QUEUE_ERROR_NONE;
}
tbm_surface_queue_error_e tbm_surface_queue_release(
tbm_surface_queue_h surface_queue, tbm_surface_h surface)
{
+ (void)surface_queue;
+ (void)surface;
+
+ return TBM_SURFACE_QUEUE_ERROR_NONE;
}
tbm_surface_queue_error_e tbm_surface_queue_add_acquirable_cb(
tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb acquirable_cb,
void *data)
{
+ (void)surface_queue;
+ (void)acquirable_cb;
+ (void)data;
+
+ return TBM_SURFACE_QUEUE_ERROR_NONE;
}
tbm_surface_queue_error_e tbm_surface_queue_add_destroy_cb(
tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb destroy_cb,
void *data)
{
+ (void)surface_queue;
+ (void)destroy_cb;
+ (void)data;
+
+ return TBM_SURFACE_QUEUE_ERROR_NONE;
}
tbm_surface_queue_error_e tbm_surface_queue_remove_acquirable_cb(
tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb acquirable_cb,
void *data)
{
+ (void)surface_queue;
+ (void)acquirable_cb;
+ (void)data;
+
+ return TBM_SURFACE_QUEUE_ERROR_NONE;
}
tbm_surface_queue_error_e tbm_surface_queue_remove_destroy_cb(
tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb destroy_cb,
void *data)
{
+ (void)surface_queue;
+ (void)destroy_cb;
+ (void)data;
+
+ return TBM_SURFACE_QUEUE_ERROR_NONE;
}
int tbm_surface_internal_get_user_data(tbm_surface_h surface, unsigned long key,
void **data)
{
+ (void)surface;
+ (void)key;
+ (void)data;
+
return 0;
}
int tbm_surface_internal_add_user_data(tbm_surface_h surface, unsigned long key,
tbm_data_free data_free_func)
{
+ (void)surface;
+ (void)key;
+ (void)data_free_func;
+
return 1;
}
int tbm_surface_internal_set_user_data(tbm_surface_h surface, unsigned long key,
void *data)
{
+ (void)surface;
+ (void)key;
+ (void)data;
+
+ return 1;
}
int tbm_surface_map(tbm_surface_h surface, int opt, tbm_surface_info_s *info)
{
+ (void)surface;
+ (void)opt;
+ (void)info;
+
+ return 0;
}
int tbm_surface_unmap(tbm_surface_h surface)
{
+ (void)surface;
+
+ return 0;
}
void tbm_surface_internal_dump_buffer(tbm_surface_h surface, const char *type)
{
+ (void)surface;
+ (void)type;
}
static tdm_capture *output_create_capture(tdm_output *output, tdm_error *error)
{
+ (void)output;
+ (void)error;
+
if (OUTPUT_CREATE_CAPTURE_ERROR) {
*error = TDM_ERROR_OPERATION_FAILED;
return NULL;
static void capture_destroy(tdm_capture *capture)
{
-
+ (void)capture;
}
static tdm_error capture_set_done_handler(tdm_capture *capture,
tdm_capture_done_handler func, void *user_data)
{
+ (void)capture;
+ (void)func;
+ (void)user_data;
+
if (CAPTURE_SET_DONE_HANDLER_ERROR) {
if (user_data) {
free(user_data);
static tdm_capture *layer_create_capture(tdm_layer *layer, tdm_error *error)
{
+ (void)layer;
+ (void)error;
+
if (LAYER_CREATE_CAPTURE_ERROR) {
*error = TDM_ERROR_OPERATION_FAILED;
return NULL;
static tdm_error capture_set_info(tdm_capture *capture, tdm_info_capture *info)
{
- if (CAPTURE_SET_INFO_ERROR) {
- return TDM_ERROR_OPERATION_FAILED;
- }
+ (void)capture;
+ (void)info;
- return TDM_ERROR_NONE;
-}
-
-static tdm_error capture_attach(tdm_capture *capture, tbm_surface_h buffer)
-{
- if (CAPTURE_ATTACH_ERROR) {
+ if (CAPTURE_SET_INFO_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
}
static tdm_error capture_commit(tdm_capture *capture)
{
+ (void)capture;
+
if (CAPTURE_COMMIT_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
}
#include "tdm_private.h"
-static int DISPLAY_GET_FD_ERROR;
static int TDM_PP_CREATE_INTERNAL_ERROR;
static int OUTPUT_SET_PROPERTY_ERROR;
static int OUTPUT_GET_PROPERTY_ERROR;
static int TDM_THREAD_HANDLE_ERROR;
static int TDM_EVENT_LOOP_DISPATCH_ERROR;
-static tdm_error display_get_fd(tdm_backend_data * bdata, int *fd)
+static tdm_private_pp *
+ut_tdm_pp_create_internal(tdm_private_display *private_display,
+ tdm_error *error)
{
- if (DISPLAY_GET_FD_ERROR) {
- return TDM_ERROR_OPERATION_FAILED;
- }
+ (void)private_display;
- return TDM_ERROR_NONE;
-
-}
-
-static tdm_private_pp *ut_tdm_pp_create_internal(tdm_private_display *
- private_display,
- tdm_error * error)
-{
if (TDM_PP_CREATE_INTERNAL_ERROR) {
if (error) {
*error = TDM_ERROR_OPERATION_FAILED;
return NULL;
}
-static tdm_error output_set_property(tdm_output * output, unsigned int id,
+static tdm_error output_set_property(tdm_output *output, unsigned int id,
tdm_value value)
{
+ (void)output;
+ (void)id;
+ (void)value;
+
if (OUTPUT_SET_PROPERTY_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
}
return TDM_ERROR_NONE;
}
-static tdm_error output_get_property(tdm_output * output, unsigned int id,
- tdm_value * value)
+static tdm_error output_get_property(tdm_output *output, unsigned int id,
+ tdm_value *value)
{
+ (void)output;
+ (void)id;
+ (void)value;
+
if (OUTPUT_GET_PROPERTY_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
}
return TDM_ERROR_NONE;
}
-static void ut_tdm_output_vblank_handler(tdm_output * output,
+static void ut_tdm_output_vblank_handler(tdm_output *output,
unsigned int sequence,
unsigned int tv_sec,
unsigned int tv_usec, void *user_data)
{
-
+ (void)output;
+ (void)sequence;
+ (void)tv_sec;
+ (void)tv_usec;
+ (void)user_data;
}
-static tdm_error output_wait_vblank(tdm_output * output, int interval, int sync,
+static tdm_error output_wait_vblank(tdm_output *output, int interval, int sync,
void *user_data)
{
+ (void)output;
+ (void)interval;
+ (void)sync;
+ (void)user_data;
+
free(user_data);
if (OUTPUT_WAIT_VBLANK_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
return TDM_ERROR_NONE;
}
-static tdm_error output_set_vblank_handler(tdm_output * output,
+static tdm_error output_set_vblank_handler(tdm_output *output,
tdm_output_vblank_handler func)
{
+ (void)output;
+ (void)func;
+
if (OUTPUT_SET_VBLANK_HANDLER) {
return TDM_ERROR_OPERATION_FAILED;
}
return TDM_ERROR_NONE;
}
-static tdm_error output_commit(tdm_output * output, int sync, void *user_data)
+static tdm_error output_commit(tdm_output *output, int sync, void *user_data)
{
+ (void)output;
+ (void)sync;
+
free(user_data);
if (OUTPUT_COMMIT_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
return TDM_ERROR_NONE;
}
-static tdm_error output_set_commit_handler(tdm_output * output,
+static tdm_error output_set_commit_handler(tdm_output *output,
tdm_output_commit_handler func)
{
+ (void)output;
+ (void)func;
+
if (OUTPUT_SET_COMMIT_HANDLER) {
return TDM_ERROR_OPERATION_FAILED;
}
return TDM_ERROR_NONE;
}
-static tdm_error output_set_mode(tdm_output * output, const tdm_output_mode * mode)
+static tdm_error output_set_mode(tdm_output *output, const tdm_output_mode *mode)
{
+ (void)output;
+ (void)mode;
+
if (OUTPUT_SET_MODE_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
}
return TDM_ERROR_NONE;
}
-static tdm_error output_set_dpms(tdm_output * output, tdm_output_dpms dpms_value)
+static tdm_error output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
{
+ (void)output;
+ (void)dpms_value;
+
if (OUTPUT_SET_DPMS_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
}
return TDM_ERROR_NONE;
}
-static tdm_error output_get_dpms(tdm_output * output, tdm_output_dpms dpms_value)
+static tdm_error output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value)
{
+ (void)output;
+ (void)dpms_value;
+
if (OUTPUT_GET_DPMS_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
}
return TDM_ERROR_NONE;
}
-static tdm_private_capture *ut_tdm_capture_create_output_internal(tdm_private_output
- *private_output,
- tdm_error *error)
+static tdm_private_capture *
+ut_tdm_capture_create_output_internal(tdm_private_output*private_output,
+ tdm_error *error)
{
+ (void)private_output;
+ (void)error;
+
if (TDM_CAPTURE_CREATE_OUTPUT_INTENAL_ERROR) {
*error = TDM_ERROR_OPERATION_FAILED;
return NULL;
static tdm_error layer_set_property(tdm_layer *layer, unsigned int id,
tdm_value value)
{
+ (void)layer;
+ (void)id;
+ (void)value;
+
if (LAYER_SET_PROPERTY_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
}
}
static tdm_error layer_get_property(tdm_layer *layer, unsigned int id,
- tdm_value value)
+ tdm_value *value)
{
+ (void)layer;
+ (void)id;
+ (void)value;
+
if (LAYER_GET_PROPERTY_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
}
static tdm_error layer_set_info(tdm_layer *layer, tdm_info_layer *info)
{
+ (void)layer;
+ (void)info;
+
if (LAYER_SET_INFO_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
}
tdm_error layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
{
+ (void)layer;
+ (void)buffer;
+
if (LAYER_SET_BUFFER_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
}
tbm_surface_h ut_tdm_buffer_ref_backend(tbm_surface_h buffer)
{
+ (void)buffer;
+
+ return NULL;
}
tdm_error layer_unset_buffer(tdm_layer *layer)
{
+ (void)layer;
+
if (LAYER_UNSET_BUFFER_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
}
static int ut_tdm_thread_get_fd(tdm_private_loop *private_loop)
{
+ (void)private_loop;
+
return 1;
}
static int ut_tdm_event_loop_get_fd(tdm_private_display *private_display)
{
+ (void)private_display;
+
return 1;
}
static tdm_error layer_set_video_pos(tdm_layer *layer, int zpos)
{
+ (void)layer;
+ (void)zpos;
+
if (LAYER_SET_VIDEO_POS_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
}
ut_tdm_capture_create_layer_internal(tdm_private_layer *private_layer,
tdm_error *error)
{
+ (void)private_layer;
+ (void)error;
+
if (CAPTURE_CREATE_LAYER_INTERNAL_ERROR) {
*error = TDM_ERROR_OPERATION_FAILED;
return NULL;
static int ut_poll(struct pollfd *fds, nfds_t nfds, int timeout)
{
+ (void)fds;
+ (void)nfds;
+ (void)timeout;
+
return 1;
}
static tdm_error ut_tdm_thread_handle_cb(tdm_private_loop *private_loop)
{
+ (void)private_loop;
+
if (TDM_THREAD_HANDLE_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
}
}
static tdm_error ut_tdm_event_loop_dispatch(tdm_private_display *private_display)
{
+ (void)private_display;
+
if (TDM_EVENT_LOOP_DISPATCH_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
}
static char *ut_getenv(const char *name)
{
+ (void)name;
+
if (GETENV_ERROR) {
return NULL;
}
- return "getenv";
+ return (char*)"getenv";
}
static int ut_sscanf(const char *buf, const char *format, ...)
{
+ (void)buf;
+ (void)format;
+
if (SSCANF_ERROR) {
return -1;
}
static int ut_fcntl(int fd, int cmd, ...)
{
+ (void)fd;
+ (void)cmd;
+
if (FCNTL_ERROR) {
return -1;
}
static int ut_dup(int fd)
{
+ (void)fd;
+
if (DUP_ERROR) {
return -1;
}
struct list_head *next;
};
-static inline void list_inithead(struct list_head *item) { }
-
-static inline void list_add(struct list_head *item, struct list_head *list) { }
-
-static inline void list_addtail(struct list_head *item, struct list_head *list) { }
-
-static inline void list_replace(struct list_head *from, struct list_head *to) { }
-
-static inline void list_del(struct list_head *item) { }
-
-static inline void list_delinit(struct list_head *item) { }
+static inline void list_inithead(struct list_head *item)
+{
+ (void)item;
+}
+
+static inline void list_add(struct list_head *item, struct list_head *list)
+{
+ (void)item;
+ (void)list;
+}
+
+static inline void list_addtail(struct list_head *item, struct list_head *list)
+{
+ (void)item;
+ (void)list;
+}
+
+static inline void list_replace(struct list_head *from, struct list_head *to)
+{
+ (void)from;
+ (void)to;
+}
+
+static inline void list_del(struct list_head *item)
+{
+ (void)item;
+}
+
+static inline void list_delinit(struct list_head *item)
+{
+ (void)item;
+}
#define LIST_INITHEAD(__item) list_inithead(__item)
#define LIST_ADD(__item, __list) list_add(__item, __list)
void
tdm_log_enable_color(unsigned int enable)
{
+ (void)enable;
}
void
tdm_log_enable_dlog(unsigned int enable)
{
+ (void)enable;
}
void
tdm_log_enable_debug(unsigned int enable)
{
+ (void)enable;
}
void
tdm_log_set_debug_level(int level)
{
+ (void)level;
}
void
tdm_log_print(int level, const char *fmt, ...)
{
+ (void)level;
+ (void)fmt;
}
static int PP_ATACH_ERROR;
static int PP_COMMIT_ERROR;
-static tdm_buffer_info *ut_tdm_buffer_get_info(tbm_surface_h buffer)
-{
-
-}
-
-static void ut_tdm_buffer_list_dump(struct list_head *list)
-{
-
-}
-
static tbm_surface_h ut_tdm_buffer_ref_backend(tbm_surface_h buffer)
{
+ (void)buffer;
+ return NULL;
}
static tdm_error pp_set_info(tdm_pp *pp, tdm_info_pp *info)
{
- if (PP_SET_INFO_ERROR) {
- return TDM_ERROR_OPERATION_FAILED;
- }
-
- return TDM_ERROR_NONE;
-}
+ (void)pp;
+ (void)info;
-static tdm_error pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst)
-{
- if (PP_ATACH_ERROR) {
+ if (PP_SET_INFO_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
}
static tdm_error pp_commit(tdm_pp *pp)
{
+ (void)pp;
+
if (PP_COMMIT_ERROR) {
return TDM_ERROR_OPERATION_FAILED;
}
tdm_error
tdm_server_init(tdm_private_loop *private_loop)
{
+ (void)private_loop;
+
+ return TDM_ERROR_NONE;
}
void
tdm_server_deinit(tdm_private_loop *private_loop)
{
+ (void)private_loop;
}
tdm_error
tdm_thread_init(tdm_private_loop *private_loop)
{
+ (void)private_loop;
+
+ return TDM_ERROR_NONE;
}
void
tdm_thread_deinit(tdm_private_loop *private_loop)
{
+ (void)private_loop;
}
int
tdm_thread_get_fd(tdm_private_loop *private_loop)
{
+ (void)private_loop;
+
+ return 0;
}
tdm_error
tdm_thread_send_cb(tdm_private_loop *private_loop, tdm_thread_cb_base *base)
{
+ (void)private_loop;
+ (void)base;
+
+ return TDM_ERROR_NONE;
}
tdm_error
tdm_thread_handle_cb(tdm_private_loop *private_loop)
{
+ (void)private_loop;
+
+ return TDM_ERROR_NONE;
}
int
tdm_thread_in_display_thread(pid_t tid)
{
+ (void)tid;
+
+ return 0;
}
int
-tdm_thread_is_running(void)
+tdm_thread_is_running()
{
return TDM_THREAD_IS_RUNNING;
}
unsigned int target_seq;
};
-static struct list_head vblank_list;
-static struct list_head valid_wait_list;
-static unsigned int vblank_list_inited;
-static unsigned int stamp = 0;
-
-static tdm_error _tdm_vblank_cb_vblank_SW(void *user_data);
-static tdm_error _tdm_vblank_wait_SW(tdm_vblank_wait_info *wait_info);
-
tdm_vblank*
tdm_vblank_create(tdm_display *dpy, tdm_output *output, tdm_error *error)
{
+ (void)dpy;
+ (void)output;
+ (void)error;
+
+ return NULL;
}
void
tdm_vblank_destroy(tdm_vblank *vblank)
{
+ (void)vblank;
}
tdm_error
tdm_vblank_set_fps(tdm_vblank *vblank, unsigned int fps)
{
+ (void)vblank;
+ (void)fps;
+
+ return TDM_ERROR_NONE;
}
tdm_error
tdm_vblank_set_offset(tdm_vblank *vblank, int offset)
{
+ (void)vblank;
+ (void)offset;
+
+ return TDM_ERROR_NONE;
}
tdm_error
tdm_vblank_set_enable_fake(tdm_vblank *vblank, unsigned int enable_fake)
{
+ (void)vblank;
+ (void)enable_fake;
+
+ return TDM_ERROR_NONE;
}
unsigned int
tdm_vblank_get_enable_fake(tdm_vblank *vblank)
{
+ (void)vblank;
+
+ return 0;
}
tdm_error
tdm_vblank_wait(tdm_vblank *vblank, unsigned int req_sec, unsigned int req_usec,
unsigned int interval, tdm_vblank_handler func, void *user_data)
{
+ (void)vblank;
+ (void)req_sec;
+ (void)req_usec;
+ (void)interval;
+ (void)func;
+ (void)user_data;
+
+ return TDM_ERROR_NONE;
}
tdm_error
tdm_vblank_wait_seq(tdm_vblank *vblank, unsigned int req_sec, unsigned int req_usec,
unsigned int sequence, tdm_vblank_handler func, void *user_data)
{
+ (void)vblank;
+ (void)req_sec;
+ (void)req_usec;
+ (void)sequence;
+ (void)func;
+ (void)user_data;
+
+ return TDM_ERROR_NONE;
}
static void wl_display_flush_clients(struct wl_display *display)
{
-
+ (void)display;
}
-static struct wl_display *wl_display_create(void)
+static struct wl_display *wl_display_create()
{
-
+ return NULL;
}
static struct wl_event_loop *wl_display_get_event_loop(struct wl_display *display)
{
+ (void)display;
+ return NULL;
}
static void wl_display_destroy(struct wl_display *display)
{
-
+ (void)display;
}
static int wl_event_loop_get_fd(struct wl_event_loop *loop)
{
-}
-
-static void wl_resource_post_error(struct wl_resource *resource,
- uint32_t code, const char *msg, ...)
-{
-
-}
-
-static struct wl_resource *wl_resource_create(struct wl_client *client,
- const struct wl_interface *interface,
- int version, uint32_t id)
-{
+ (void)loop;
+ return 0;
}
typedef void (*wl_global_bind_func_t)(struct wl_client *client, void *data,
uint32_t version, uint32_t id);
-static struct wl_global *wl_global_create(struct wl_display *display,
- const struct wl_interface *interface,
- int version, void *data,
- wl_global_bind_func_t bind);
-
static int wl_event_loop_dispatch(struct wl_event_loop *loop, int timeout)
{
+ (void)loop;
+ (void)timeout;
+ return 0;
}
typedef int (*wl_event_loop_fd_func_t)(int fd, uint32_t wl_mask, void *data);
wl_event_loop_fd_func_t func,
void *data)
{
+ (void)loop;
+ (void)fd;
+ (void)mask;
+ (void)func;
+ (void)data;
+
if (WL_EVENT_LOOP_ADD_FD_ERROR) {
return NULL;
}
static int wl_event_source_fd_update(struct wl_event_source *source, uint32_t mask)
{
+ (void)source;
+ (void)mask;
+
if (WL_EVENT_SOURCE_FD_UPDATE_ERROR) {
return -1;
}
wl_event_loop_timer_func_t func,
void *data)
{
+ (void)loop;
+ (void)func;
+ (void)data;
+
if (WL_EVENT_LOOP_ADD_TIMER_ERROR) {
return NULL;
}
static int wl_event_source_timer_update(struct wl_event_source *source, int ms_delay)
{
+ (void)source;
+ (void)ms_delay;
+
if (WL_EVENT_SOURCE_TIMER_UPDATE_ERROR) {
return -1;
}
static int wl_event_source_remove(struct wl_event_source *source)
{
+ (void)source;
-}
-
-static uint32_t wl_resource_get_id(struct wl_resource *resource)
-{
-
-}
-
-static void wl_tdm_vblank_send_done(struct wl_resource *resource, unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec)
-{
-
-}
-
-static void wl_resource_destroy(struct wl_resource *resource)
-{
-
-}
-
-static void *wl_resource_get_user_data(struct wl_resource *resource)
-{
-
-}
-
-static int wl_resource_get_version(struct wl_resource *resource)
-{
-
-}
-
-static void wl_resource_post_no_memory(struct wl_resource *resource)
-{
-
+ return 0;
}
typedef void (*wl_resource_destroy_func_t) (struct wl_resource *resource);
-static void wl_resource_set_implementation(struct wl_resource *resource,
- const void *implementation,
- void *data,
- wl_resource_destroy_func_t destroy)
-{
-
-}
-
-static void wl_client_post_no_memory(struct wl_client *client)
-{
-
-}
-
-static int wl_display_add_socket(struct wl_display *display, const char *name)
-{
-
-}
-
-static struct wl_global *wl_global_create(struct wl_display *display,
- const struct wl_interface *interface,
- int version, void *data,
- wl_global_bind_func_t bind)
-{
-
-}
-
#endif /* WAYLAND_SERVER_CORE_H */
wl_tbm_drm_auth_add_listener(struct wl_tbm_drm_auth *wl_tbm_drm_auth,
const struct wl_tbm_drm_auth_listener *listener, void *data)
{
+ (void)wl_tbm_drm_auth;
+ (void)listener;
+ (void)data;
+
+ return 0;
}
#define WL_TBM_DRM_AUTH_GET_AUTHENTICATION_INFO 0
static inline void
wl_tbm_drm_auth_set_user_data(struct wl_tbm_drm_auth *wl_tbm_drm_auth, void *user_data)
{
+ (void)wl_tbm_drm_auth;
+ (void)user_data;
}
static inline void *
wl_tbm_drm_auth_get_user_data(struct wl_tbm_drm_auth *wl_tbm_drm_auth)
{
+ (void)wl_tbm_drm_auth;
+
+ return NULL;
}
static inline void
wl_tbm_drm_auth_destroy(struct wl_tbm_drm_auth *wl_tbm_drm_auth)
{
+ (void)wl_tbm_drm_auth;
}
static inline void
wl_tbm_drm_auth_get_authentication_info(struct wl_tbm_drm_auth *wl_tbm_drm_auth)
{
+ (void)wl_tbm_drm_auth;
}
#endif
projects / platform / core / uifw / libtdm.git / commitdiff