* Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
*
* Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
+ * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
+ * Contact: Roman Marchenko <r.marchenko@samsung.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
**************************************************************************/
#include "gtest/gtest.h"
+#include "ut_common.h"
+#include "tdm.h"
+extern "C" {
+#include "tbm_bufmgr.h"
+#include "tbm_drm_helper.h"
+}
+
+#include <sys/epoll.h>
+#include <sys/timerfd.h>
+#include <list>
+#include <limits.h>
+
+#define SIZE_ALIGN(value, base) (((value) + ((base) - 1)) & ~((base) - 1))
+
+class TDMPPWithoutCreation : public testing::Test {
+protected:
+ tdm_display *dpy = NULL;
+ tbm_bufmgr bufmgr;
+ tdm_display_capability display_capability = (tdm_display_capability)0;
+ bool has_pp = false;
+ std::list<tbm_surface_h> buffers_list;
+
+ virtual void SetEnvs()
+ {
+ setenv("TDM_DLOG", "1", 1);
+ setenv("XDG_RUNTIME_DIR", "/run", 1);
+ setenv("TBM_DLOG", "1", 1);
+ setenv("TDM_DEBUG_MODULE", "all", 1);
+ setenv("TDM_DEBUG", "1", 1);
+ setenv("TBM_DISPLAY_SERVER", "1", 1);
+ }
-#include "tbm_stubs.h"
-#include "stub_pthread.h"
-#include "stub_stdlib.h"
-#include "stub_tdm_helper.h"
-#include "stub_backend.h"
-#include "stub_tdm_buffer.h"
-#include "stub_unistd.h"
-#include "stub_tdm_thread.h"
-#include "stub_tdm_helper.h"
-#include "stub_tdm_buffer.h"
-
-#include "tdm_pp.c"
-
-//local stubs for callbeck functions
-static int stub_pp_destroy_is_called = 0;
-static int stub_tdm_pp_done_handler_is_called;
-
-static void stub_pp_destroy(tdm_pp *pp)
-{
- (void)pp;
+ virtual void UnsetEnvs()
+ {
+ unsetenv("TDM_DLOG");
+ unsetenv("XDG_RUNTIME_DIR");
+ unsetenv("TBM_DLOG");
+ unsetenv("TDM_DEBUG_MODULE");
+ unsetenv("TDM_DEBUG");
+ unsetenv("TBM_DISPLAY_SERVER");
+ }
- stub_pp_destroy_is_called = 1;
-}
+ void SetUp(void)
+ {
+ tdm_error error = TDM_ERROR_NONE;
-static int stub_pp_set_done_handler_is_called = 0;
-static int stub_pp_set_done_handler_error = 0;
-static tdm_error stub_pp_set_done_handler(tdm_pp *pp, tdm_pp_done_handler func,
- void *user_data)
-{
- (void)pp;
- (void)func;
- (void)user_data;
+ SetEnvs();
- if (stub_pp_set_done_handler_error)
- return TDM_ERROR_OPERATION_FAILED;
+ bufmgr = tbm_bufmgr_init(-1);
+ ASSERT_FALSE(bufmgr == NULL);
- stub_pp_set_done_handler_is_called = 1;
- return TDM_ERROR_NONE;
-}
+ dpy = tdm_display_init(&error);
+ ASSERT_TRUE(error == TDM_ERROR_NONE);
+ ASSERT_FALSE(dpy == NULL);
-static int stub_display_create_pp_is_called = 0;
-static int stub_display_create_pp_error = 0;
-static tdm_pp *stub_display_create_pp(tdm_backend_data *bdata, tdm_error *error)
-{
- (void)bdata;
+ error = tdm_display_get_capabilities(dpy, &display_capability);
+#ifdef FAIL_ON_UNSUPPORTED
+ ASSERT_TRUE(display_capability & TDM_DISPLAY_CAPABILITY_PP);
+#endif
+ ASSERT_TRUE(error == TDM_ERROR_NONE);
- if (stub_display_create_pp_error) {
- if (error)
- *error = TDM_ERROR_OPERATION_FAILED;
- return NULL;
+ if (display_capability & TDM_DISPLAY_CAPABILITY_PP)
+ has_pp = true;
}
- stub_display_create_pp_is_called = 1;
- static int backend_pp;
- return &backend_pp;
-}
-
-static int stub_pp_attach_is_called = 0;
-static int stub_pp_attach_error = 0;
-tdm_error stub_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst)
-{
- (void)pp;
- (void)src;
- (void)dst;
- if (stub_pp_attach_error)
- return TDM_ERROR_OPERATION_FAILED;
-
- stub_pp_attach_is_called = 1;
- return TDM_ERROR_NONE;
-}
+ void TearDown(void)
+ {
+ if (dpy)
+ tdm_display_deinit(dpy);
+ if (bufmgr)
+ tbm_bufmgr_deinit(bufmgr);
-static void stub_tdm_pp_done_handler(tdm_pp *pp, tbm_surface_h src,
- tbm_surface_h dst, void *user_data)
-{
- (void)pp;
- (void)src;
- (void)dst;
- (void)user_data;
+ UnsetEnvs();
+ }
+};
+
+class TDMPP : public TDMPPWithoutCreation {
+protected:
+ tdm_pp *pp = NULL;
+ const tbm_format *formats = NULL;
+ int format_count = 0;
+ int min_w = 0;
+ int min_h = 0;
+ int max_w = 0;
+ int max_h = 0;
+ int preferred_align = 0;
+ int default_src_w = 128;
+ int default_src_h = 256;
+ int default_dst_w = 512;
+ int default_dst_h = 1024;
+
+ void SetUp(void)
+ {
+ tdm_error error;
+
+ ASSERT_NO_FATAL_FAILURE(TDMPPWithoutCreation::SetUp());
+
+ if (!has_pp)
+ return;
+
+ pp = tdm_display_create_pp(dpy, &error);
+ ASSERT_NE(NULL, pp);
+ ASSERT_EQ(TDM_ERROR_NONE, error);
+
+ error =
+ tdm_display_get_pp_available_formats(dpy, &formats, &format_count);
+ ASSERT_EQ(TDM_ERROR_NONE, error);
+ ASSERT_NE(NULL, formats);
+ ASSERT_GE(format_count, 0);
+
+ error =
+ tdm_display_get_pp_available_size(dpy, &min_w, &min_h,
+ &max_w, &max_h, &preferred_align);
+ ASSERT_EQ(TDM_ERROR_NONE, error);
+ if (preferred_align > 0) {
+ default_src_w = SIZE_ALIGN(default_src_w, preferred_align);
+ default_src_h = SIZE_ALIGN(default_src_h, preferred_align);
+ default_dst_w = SIZE_ALIGN(default_dst_w, preferred_align);
+ default_dst_h = SIZE_ALIGN(default_dst_h, preferred_align);
+ }
+ if (min_w > default_src_w)
+ default_src_w = min_w;
+ if (min_h > default_src_h)
+ default_src_h = min_h;
+ if (max_w > 0 && max_w < default_dst_w)
+ default_dst_w = max_w;
+ if (max_h > 0 && max_h < default_dst_h)
+ default_dst_h = max_h;
+ }
- stub_tdm_pp_done_handler_is_called = 1;
-}
+ void TearDown(void)
+ {
+ if (pp)
+ tdm_pp_destroy(pp);
-static void _init_test()
-{
- stub_tdm_buffer_init();
- stub_tdm_helper_init();
- stub_tdm_buffer_init();
- stub_tdm_thread_init();
- stub_unistd_init();
- stub_pthread_init();
- stub_backend_init();
- stub_tbm_init();
- stub_stdlib_init();
- stub_pp_destroy_is_called = 0;
- stub_pp_set_done_handler_is_called = 0;
- stub_pp_set_done_handler_error = 0;
- stub_display_create_pp_is_called = 0;
- stub_pp_attach_is_called = 0;
- stub_pp_attach_error = 0;
- stub_tdm_pp_done_handler_is_called = 0;
- stub_display_create_pp_error = 0;
- tdm_debug_dump = TDM_DUMP_FLAG_PP;
- tdm_debug_module = TDM_DEBUG_BUFFER;
-}
+ for (auto it = buffers_list.begin(); it != buffers_list.end(); ++it) {
+ tbm_surface_destroy(*it);
+ }
-/* UNIT TESTS */
+ buffers_list.clear();
-/* tdm_pp_commit */
+ TDMPPWithoutCreation::TearDown();
+ }
-TEST(tdm_pp_commit, work_flow_success_3)
-{
- tdm_error error = TDM_ERROR_OPERATION_FAILED;
- tdm_private_pp pp;
- tdm_private_display private_display;
- tdm_pp_private_buffer b_1, b_2;
+ void UtGetPPInfoWithScale(tdm_info_pp *info)
+ {
+ memset((void *)info, 0, sizeof(tdm_info_pp));
+
+ info->src_config.size.h = default_src_w;
+ info->src_config.size.v = default_src_h;
+ info->src_config.pos.x = 0;
+ info->src_config.pos.y = 0;
+ info->src_config.pos.w = default_src_w;
+ info->src_config.pos.h = default_src_h;
+ info->src_config.format = formats[0];
+ info->dst_config.size.h = default_dst_w;
+ info->dst_config.size.v = default_dst_h;
+ info->dst_config.pos.x = 0;
+ info->dst_config.pos.y = 0;
+ info->dst_config.pos.w = default_dst_w;
+ info->dst_config.pos.h = default_dst_h;
+ info->dst_config.format = formats[0];
+ }
- _init_test();
+ void UtGetPPInfoWithScaleAndTransform(tdm_info_pp *info)
+ {
+ UtGetPPInfoWithScale(info);
- pp.private_display = &private_display;
- private_display.func_pp.pp_commit = pp_commit;
+ info->transform = TDM_TRANSFORM_180;
+ }
- LIST_INITHEAD(&pp.pending_buffer_list);
- LIST_INITHEAD(&pp.buffer_list);
+ void UtGetPPInfoWithWrongInfo(tdm_info_pp *info)
+ {
+ info->src_config.size.h = UINT_MAX;
+ info->src_config.size.v = UINT_MAX;
+ info->src_config.pos.x = 0;
+ info->src_config.pos.y = 0;
+ info->src_config.pos.w = UINT_MAX;
+ info->src_config.pos.h = UINT_MAX;
+ info->src_config.format = INT_MAX;
+ info->dst_config.size.h = UINT_MAX;
+ info->dst_config.size.v = UINT_MAX;
+ info->dst_config.pos.x = 0;
+ info->dst_config.pos.y = 0;
+ info->dst_config.pos.w = UINT_MAX;
+ info->dst_config.pos.h = UINT_MAX;
+ info->dst_config.format = INT_MAX;
+ }
- LIST_ADD(&b_1.link, &pp.pending_buffer_list);
- LIST_ADD(&b_2.link, &pp.pending_buffer_list);
+ tbm_surface_h
+ UtCreateBuffer(int w, int h, tbm_format format)
+ {
+ tbm_surface_h buffer;
+ buffer = tbm_surface_create(w, h, format);
+ if (buffer)
+ buffers_list.push_back(buffer);
- error = tdm_pp_commit(&pp);
+ return buffer;
+ }
+};
+
+void UtPpDoneHandler(tdm_pp *pp, tbm_surface_h src,
+ tbm_surface_h dst, void *user_data);
+
+class TDMPPCommit : public TDMPP {
+public:
+ friend void UtPpDoneHandler(tdm_pp *pp, tbm_surface_h src,
+ tbm_surface_h dst, void *user_data);
+private:
+ int epFd = -1;
+ int timerFd = -1;
+ int tdmFd = -1;
+ static const int timeLimitSec = 0;
+ static const int timeLimitNsec = 100000000;
+protected:
+ int utPpDoneHandlerSuccessCounter = 0;
+
+ void SetUp(void)
+ {
+ struct epoll_event ep;
+
+ ASSERT_NO_FATAL_FAILURE(TDMPP::SetUp());
+
+ epFd = epoll_create1(0);
+ ASSERT_TRUE(epFd != -1);
+
+ timerFd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);
+ ASSERT_TRUE(timerFd != -1);
+
+ memset(&ep, 0, sizeof ep);
+ ep.events |= EPOLLIN;
+ ep.data.fd = timerFd;
+ ASSERT_TRUE(epoll_ctl(epFd, EPOLL_CTL_ADD, timerFd, &ep) == 0);
+
+ ASSERT_TRUE(tdm_display_get_fd(dpy, &tdmFd) == TDM_ERROR_NONE);
+
+ memset(&ep, 0, sizeof ep);
+ ep.events |= EPOLLIN;
+ ep.data.fd = tdmFd;
+ ASSERT_TRUE(epoll_ctl(epFd, EPOLL_CTL_ADD, tdmFd, &ep) == 0);
+ }
- ASSERT_EQ(error, TDM_ERROR_NONE);
- ASSERT_EQ(LIST_LENGTH(&pp.buffer_list), 2);
-}
+ void TearDown(void)
+ {
+ if (epFd)
+ close(epFd);
+ if (timerFd)
+ close(timerFd);
-//TEST(tdm_pp_commit, work_flow_success_2)
-//{
-// tdm_error error = TDM_ERROR_NONE;
-// tdm_error not_expected_error = TDM_ERROR_NONE;
-// tdm_private_pp pp;
-// tdm_private_display private_display;
-// tdm_pp_private_buffer b_1, b_2;
-//
-// _init_test();
-//
-// pp.private_display = &private_display;
-// private_display.func_pp.pp_commit = pp_commit;
-// PP_COMMIT_ERROR = 1;
-//
-// LIST_INITHEAD(&pp.pending_buffer_list);
-// LIST_INITHEAD(&pp.buffer_list);
-//
-// LIST_ADD(&b_1.link, &pp.pending_buffer_list);
-// LIST_ADD(&b_2.link, &pp.pending_buffer_list);
-//
-// error = tdm_pp_commit(&pp);
-//
-// ASSERT_NE(error, not_expected_error);
-// ASSERT_EQ(LIST_LENGTH(&pp.buffer_list), 0);
-// ASSERT_EQ(stub_tdm_buffer_remove_release_handler_internal_count, 4);
-// ASSERT_EQ(stub_tdm_buffer_unref_backend_count, 4);
-//}
-
-TEST(tdm_pp_commit, work_flow_success_1)
-{
- tdm_error error = TDM_ERROR_NONE;
- tdm_error expected_error = TDM_ERROR_NOT_IMPLEMENTED;
- tdm_private_pp pp;
- tdm_private_display private_display;
+ TDMPP::TearDown();
+ }
- _init_test();
+ void UtHandlePPEvent(int num_attached_buffers)
+ {
+ struct itimerspec its;
+ int count;
+ struct epoll_event ep_event[2];
+
+ if (utPpDoneHandlerSuccessCounter == num_attached_buffers)
+ return;
+
+ its.it_interval.tv_sec = 0;
+ its.it_interval.tv_nsec = 0;
+ its.it_value.tv_sec = timeLimitSec;
+ its.it_value.tv_nsec = timeLimitNsec;
+
+ ASSERT_TRUE(timerfd_settime(timerFd, 0, &its, NULL) == 0);
+
+ while (1) {
+ count = epoll_wait(epFd, ep_event, sizeof(ep_event), -1);
+ ASSERT_TRUE(count >= 0);
+
+ for (int i = 0; i < count; i++) {
+ if (ep_event[i].data.fd == timerFd) {
+ return;
+ } else {
+ ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
+ if (utPpDoneHandlerSuccessCounter == num_attached_buffers)
+ return;
+ }
+ }
+ }
+ }
- pp.private_display = &private_display;
- private_display.func_pp.pp_commit = NULL;
+ int UtPrepareToPP(tdm_info_pp *info)
+ {
+ tdm_error error;
+ tbm_surface_h src_buf, dst_buf;
+
+ error = tdm_pp_set_done_handler(pp, UtPpDoneHandler, this);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
+ if (error != TDM_ERROR_NONE)
+ return -1;
+
+ error = tdm_pp_set_info(pp, info);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
+ if (error != TDM_ERROR_NONE)
+ return -1;
+
+ src_buf = UtCreateBuffer(info->src_config.pos.w, info->src_config.pos.h,
+ info->src_config.format);
+ EXPECT_NE(NULL, src_buf);
+ if (!src_buf)
+ return -1;
+
+ dst_buf = UtCreateBuffer(info->dst_config.pos.w, info->dst_config.pos.h,
+ info->dst_config.format);
+ EXPECT_NE(NULL, dst_buf);
+ if (!dst_buf)
+ return -1;
+
+ error = tdm_pp_attach(pp, src_buf, dst_buf);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
+ if (error != TDM_ERROR_NONE)
+ return -1;
+
+ return 0;
+ }
- error = tdm_pp_commit(&pp);
+ int UtPrepareToPPWithScale()
+ {
+ tdm_info_pp info = {0};
- ASSERT_EQ(error, expected_error);
-}
+ UtGetPPInfoWithScale(&info);
-TEST(tdm_pp_commit, null_ptr_fail_1)
-{
- tdm_error error = TDM_ERROR_NONE;
- tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
+ return UtPrepareToPP(&info);
+ }
- _init_test();
+ int UtPrepareToPPWithScaleAndTransform()
+ {
+ tdm_info_pp info = {0};
- error = tdm_pp_commit(NULL);
+ UtGetPPInfoWithScaleAndTransform(&info);
- ASSERT_EQ(error, expected_error);
-}
+ return UtPrepareToPP(&info);
+ }
-/* tdm_pp_attach */
+ int UtPrepareToPPWithWrongInfo()
+ {
+ tdm_info_pp info = {0};
+ tdm_error error;
+ int ret;
-TEST(tdm_pp_attach, error_pp_attach)
-{
- tdm_error error = TDM_ERROR_NONE;
- tdm_private_pp private_pp;
- tdm_private_display private_display;
- tdm_backend_module module;
- struct _tbm_surface src;
- struct _tbm_surface dst;
+ UtGetPPInfoWithScale(&info);
- _init_test();
+ ret = UtPrepareToPP(&info);
+ if (ret < 0)
+ return ret;
- LIST_INITHEAD(&private_display.pp_list);
- LIST_ADDTAIL(&private_pp.link, &private_display.pp_list);
- private_display.module_data = &module;
- private_display.func_pp.pp_attach = stub_pp_attach;
- private_display.caps_pp.max_attach_count = 3;
- module.abi_version = 0x00010002;
+ UtGetPPInfoWithWrongInfo(&info);
- private_pp.private_display = &private_display;
- LIST_INITHEAD(&private_pp.pending_buffer_list);
- LIST_INITHEAD(&private_pp.buffer_list);
+ error = tdm_pp_set_info(pp, &info);
+ EXPECT_EQ(TDM_ERROR_NONE, error);
+ if (error != TDM_ERROR_NONE)
+ return -1;
- stub_pp_attach_error = 1;
+ return 0;
+ }
- error = tdm_pp_attach(&private_pp, &src, &dst);
+};
- ASSERT_NE(TDM_ERROR_NONE, error);
-}
+class TDMPPCommitThread : public TDMPPCommit {
+protected:
+ void SetEnvs()
+ {
+ TDMPPCommit::SetEnvs();
+ setenv("TDM_THREAD", "1", 1);
+ }
+ void UnsetEnvs()
+ {
+ TDMPPCommit::UnsetEnvs();
+ unsetenv("TDM_THREAD");
+ }
+};
-TEST(tdm_pp_attach, error_calloc_error)
+void UtPpDoneHandler(tdm_pp *pp, tbm_surface_h src,
+ tbm_surface_h dst, void *user_data)
{
- tdm_error error = TDM_ERROR_NONE;
- tdm_private_pp private_pp;
- tdm_private_display private_display;
- tdm_backend_module module;
- struct _tbm_surface src;
- struct _tbm_surface dst;
-
- _init_test();
-
- LIST_INITHEAD(&private_display.pp_list);
- LIST_ADDTAIL(&private_pp.link, &private_display.pp_list);
- private_display.module_data = &module;
- private_display.func_pp.pp_attach = stub_pp_attach;
- private_display.caps_pp.max_attach_count = 3;
- module.abi_version = 0x00010002;
-
- private_pp.private_display = &private_display;
- LIST_INITHEAD(&private_pp.pending_buffer_list);
- LIST_INITHEAD(&private_pp.buffer_list);
+ TDMPPCommit *pp_commit = (TDMPPCommit *)user_data;
+ bool src_valid = false, dst_valid = false;
- CALLOC_ERROR = 1;
+ if (!pp_commit)
+ return;
- error = tdm_pp_attach(&private_pp, &src, &dst);
+ for (auto it = pp_commit->buffers_list.begin(); it != pp_commit->buffers_list.end(); ++it) {
+ if (*it == src)
+ src_valid = true;
+ if (*it == dst)
+ dst_valid = true;
+ }
- ASSERT_EQ(TDM_ERROR_OUT_OF_MEMORY, error);
+ if (src_valid && dst_valid)
+ pp_commit->utPpDoneHandlerSuccessCounter++;
}
-TEST(tdm_pp_attach, error_bad_request)
+TEST_F(TDMPPWithoutCreation, DisplayGetPPAvailableFormatsSuccessful)
{
- tdm_error error = TDM_ERROR_NONE;
- tdm_private_pp private_pp;
- tdm_private_display private_display;
- tdm_backend_module module;
- struct _tbm_surface src;
- struct _tbm_surface dst;
- tdm_pp_private_buffer pp_buffer_1;
- tdm_pp_private_buffer pp_buffer_2;
-
- _init_test();
-
- LIST_INITHEAD(&private_display.pp_list);
- LIST_ADDTAIL(&private_pp.link, &private_display.pp_list);
- private_display.module_data = &module;
- private_display.func_pp.pp_attach = stub_pp_attach;
- private_display.caps_pp.max_attach_count = 1;
- module.abi_version = 0x00010002;
-
- private_pp.private_display = &private_display;
- LIST_INITHEAD(&private_pp.pending_buffer_list);
- LIST_INITHEAD(&private_pp.buffer_list);
-
- LIST_ADD(&pp_buffer_1.link, &private_pp.pending_buffer_list);
- LIST_ADD(&pp_buffer_2.link, &private_pp.pending_buffer_list);
-
- error = tdm_pp_attach(&private_pp, &src, &dst);
-
- ASSERT_EQ(TDM_ERROR_BAD_REQUEST, error);
+ SKIP_FLAG(has_pp);
+ const tbm_format *formats = NULL;
+ int count = -42;
+ ASSERT_TRUE(TDM_ERROR_NONE == tdm_display_get_pp_available_formats(dpy, &formats, &count));
+ ASSERT_FALSE(-42 == count);
+ ASSERT_FALSE(NULL == formats);
}
-TEST(tdm_pp_attach, error_pp_attach_is_not_implemented)
-{
- tdm_error error = TDM_ERROR_NONE;
- tdm_private_pp private_pp;
- tdm_private_display private_display;
- struct _tbm_surface src;
- struct _tbm_surface dst;
-
- _init_test();
-
- private_display.func_pp.pp_attach = NULL;
-
- private_pp.private_display = &private_display;
+/* tdm_display_create_pp() */
- error = tdm_pp_attach(&private_pp, &src, &dst);
-
- ASSERT_EQ(TDM_ERROR_NOT_IMPLEMENTED, error);
-}
-
-TEST(tdm_pp_attach, work_flow_success_1)
+TEST_F(TDMPPWithoutCreation, DisplayCreatePPNullAll)
{
- tdm_error error = TDM_ERROR_NONE;
- tdm_private_pp private_pp;
- tdm_private_display private_display;
- tdm_backend_module module;
- struct _tbm_surface src;
- struct _tbm_surface dst;
-
- _init_test();
-
- LIST_INITHEAD(&private_display.pp_list);
- LIST_ADDTAIL(&private_pp.link, &private_display.pp_list);
- private_display.module_data = &module;
- private_display.func_pp.pp_attach = stub_pp_attach;
- private_display.caps_pp.max_attach_count = 3;
- module.abi_version = 0x00010002;
-
- private_pp.private_display = &private_display;
- LIST_INITHEAD(&private_pp.pending_buffer_list);
- LIST_INITHEAD(&private_pp.buffer_list);
- tdm_debug_dump = TDM_DUMP_FLAG_PP;
- tdm_debug_module = TDM_DEBUG_BUFFER;
-
- error = tdm_pp_attach(&private_pp, &src, &dst);
+ SKIP_FLAG(has_pp);
+ tdm_pp *pp;
- ASSERT_EQ(TDM_ERROR_NONE, error);
- int num_of_pp_buff = LIST_LENGTH(&private_pp.pending_buffer_list);
- ASSERT_EQ(1, num_of_pp_buff);
+ pp = tdm_display_create_pp(NULL, NULL);
+ ASSERT_EQ(NULL, pp);
}
-TEST(tdm_pp_attach, null_ptr_fail_3)
+TEST_F(TDMPPWithoutCreation, DisplayCreatePPNullDpy)
{
- tdm_error error = TDM_ERROR_NONE;
- tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
- tdm_private_pp pp;
- tdm_private_display private_display;
- struct _tbm_surface src;
-
- _init_test();
-
- pp.private_display = &private_display;
-
- error = tdm_pp_attach(&pp, &src, NULL);
+ SKIP_FLAG(has_pp);
+ tdm_pp *pp;
+ tdm_error error;
- ASSERT_EQ(error, expected_error);
+ pp = tdm_display_create_pp(NULL, &error);
+ ASSERT_EQ(NULL, pp);
+ ASSERT_NE(TDM_ERROR_NONE, error);
}
-TEST(tdm_pp_attach, null_ptr_fail_2)
+TEST_F(TDMPPWithoutCreation, DisplayCreatePPSuccessNullError)
{
- tdm_error error = TDM_ERROR_NONE;
- tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
- tdm_private_pp pp;
- tdm_private_display private_display;
- struct _tbm_surface dst;
+ SKIP_FLAG(has_pp);
+ tdm_pp *pp;
- _init_test();
-
- pp.private_display = &private_display;
-
- error = tdm_pp_attach(&pp, NULL, &dst);
-
- ASSERT_EQ(error, expected_error);
+ pp = tdm_display_create_pp(dpy, NULL);
+ ASSERT_NE(NULL, pp);
}
-TEST(tdm_pp_attach, null_ptr_fail_1)
+TEST_F(TDMPPWithoutCreation, DisplayCreatePPSuccess)
{
- tdm_error error = TDM_ERROR_NONE;
- tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
- struct _tbm_surface src;
- struct _tbm_surface dst;
-
- _init_test();
-
- error = tdm_pp_attach(NULL, &src, &dst);
+ SKIP_FLAG(has_pp);
+ tdm_pp *pp;
+ tdm_error error;
- ASSERT_EQ(error, expected_error);
+ pp = tdm_display_create_pp(dpy, &error);
+ ASSERT_NE(NULL, pp);
+ ASSERT_EQ(TDM_ERROR_NONE, error);
}
-/* tdm_pp_set_info */
+/* tdm_pp_set_info() */
-TEST(tdm_pp_set_info, work_flow_success_3)
+TEST_F(TDMPP, PpSetInfoNullAll)
{
- tdm_error error = TDM_ERROR_OPERATION_FAILED;
- tdm_error expected_error = TDM_ERROR_NONE;
- tdm_info_pp info;
- tdm_private_pp pp;
- tdm_private_display private_display;
-
- _init_test();
-
- pp.private_display = &private_display;
- private_display.func_pp.pp_set_info = pp_set_info;
-
- error = tdm_pp_set_info(&pp, &info);
+ SKIP_FLAG(has_pp);
+ tdm_error error;
- ASSERT_EQ(error, expected_error);
+ error = tdm_pp_set_info(NULL, NULL);
+ ASSERT_NE(TDM_ERROR_NONE, error);
}
-TEST(tdm_pp_set_info, work_flow_success_2)
+TEST_F(TDMPP, PpSetInfoNullPP)
{
- tdm_error error = TDM_ERROR_NONE;
- tdm_error not_expected_error = TDM_ERROR_NONE;
+ SKIP_FLAG(has_pp);
+ tdm_error error;
tdm_info_pp info;
- tdm_private_pp pp;
- tdm_private_display private_display;
- _init_test();
-
- pp.private_display = &private_display;
- private_display.func_pp.pp_set_info = pp_set_info;
- PP_SET_INFO_ERROR = 1;
+ error = tdm_pp_set_info(NULL, &info);
+ ASSERT_NE(TDM_ERROR_NONE, error);
+}
- error = tdm_pp_set_info(&pp, &info);
+TEST_F(TDMPP, PpSetInfoNullInfo)
+{
+ SKIP_FLAG(has_pp);
+ tdm_error error;
- ASSERT_NE(error, not_expected_error);
+ error = tdm_pp_set_info(pp, NULL);
+ ASSERT_NE(TDM_ERROR_NONE, error);
}
-TEST(tdm_pp_set_info, work_flow_success_1)
+TEST_F(TDMPP, PpSetInfoSuccess)
{
- tdm_error error = TDM_ERROR_NONE;
- tdm_error expected_error = TDM_ERROR_NOT_IMPLEMENTED;
+ SKIP_FLAG(has_pp);
+ tdm_error error;
tdm_info_pp info;
- tdm_private_pp pp;
- tdm_private_display private_display;
-
- _init_test();
-
- pp.private_display = &private_display;
- private_display.func_pp.pp_set_info = NULL;
- error = tdm_pp_set_info(&pp, &info);
+ UtGetPPInfoWithScale(&info);
- ASSERT_EQ(error, expected_error);
+ error = tdm_pp_set_info(pp, &info);
+ ASSERT_EQ(TDM_ERROR_NONE, error);
}
-TEST(tdm_pp_set_info, null_ptr_fail_2)
-{
- tdm_error error = TDM_ERROR_NONE;
- tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
- tdm_private_pp pp;
- tdm_private_display private_display;
-
- _init_test();
+/* tdm_pp_set_done_handler() */
- pp.private_display = &private_display;
-
- error = tdm_pp_set_info(&pp, NULL);
+TEST_F(TDMPP, PpSetDoneHandlerFailNullAll)
+{
+ SKIP_FLAG(has_pp);
+ tdm_error error;
- ASSERT_EQ(error, expected_error);
+ error = tdm_pp_set_done_handler(NULL, NULL, NULL);
+ ASSERT_NE(TDM_ERROR_NONE, error);
}
-TEST(tdm_pp_set_info, null_ptr_fail_1)
+TEST_F(TDMPP, PpSetDoneHandlerFailNullPP)
{
- tdm_error error = TDM_ERROR_NONE;
- tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
- tdm_info_pp info;
-
- _init_test();
-
- error = tdm_pp_set_info(NULL, &info);
+ SKIP_FLAG(has_pp);
+ tdm_error error;
- ASSERT_EQ(error, expected_error);
+ error = tdm_pp_set_done_handler(NULL, UtPpDoneHandler, this);
+ ASSERT_NE(TDM_ERROR_NONE, error);
}
-TEST(tdm_pp_set_done_handler, work_flow_success_1)
+TEST_F(TDMPP, PpSetDoneHandlerSuccessNullFailNullFunc)
{
+ SKIP_FLAG(has_pp);
tdm_error error;
- tdm_private_pp pp;
- tdm_private_display private_display;
- int user_data = 0;
-
- _init_test();
+ int data;
- pp.private_display = &private_display;
- private_display.func_pp.pp_set_info = NULL;
+ error = tdm_pp_set_done_handler(pp, NULL, &data);
+ ASSERT_NE(TDM_ERROR_NONE, error);
+}
- error = tdm_pp_set_done_handler(&pp, stub_tdm_pp_done_handler, &user_data);
- ASSERT_EQ(TDM_ERROR_NONE, error);
- ASSERT_EQ(stub_tdm_pp_done_handler, pp.done_func);
- ASSERT_EQ(&user_data, pp.done_user_data);
+TEST_F(TDMPP, PpSetDoneHandlerSuccessNullData)
+{
+ SKIP_FLAG(has_pp);
+ tdm_error error;
- error = tdm_pp_set_done_handler(&pp, stub_tdm_pp_done_handler, NULL);
+ error = tdm_pp_set_done_handler(pp, UtPpDoneHandler, this);
ASSERT_EQ(TDM_ERROR_NONE, error);
- ASSERT_EQ(TDM_ERROR_NONE, error);
- ASSERT_EQ(stub_tdm_pp_done_handler, pp.done_func);
- ASSERT_EQ(0, pp.done_user_data);
}
-TEST(tdm_pp_set_done_handler, work_flow_error_1___NULL)
+TEST_F(TDMPP, PpSetDoneHandlerSuccess)
{
+ SKIP_FLAG(has_pp);
tdm_error error;
- tdm_private_pp pp;
- tdm_private_display private_display;
- _init_test();
+ error = tdm_pp_set_done_handler(pp, UtPpDoneHandler, this);
+ ASSERT_EQ(TDM_ERROR_NONE, error);
+}
- pp.private_display = &private_display;
- private_display.func_pp.pp_set_info = NULL;
+/* tdm_pp_attach() */
- error = tdm_pp_set_done_handler(&pp, NULL, NULL);
- ASSERT_NE(TDM_ERROR_NONE, error);
+TEST_F(TDMPP, PpAttachFailNullAll)
+{
+ SKIP_FLAG(has_pp);
+ tdm_error error;
- error = tdm_pp_set_done_handler(NULL, stub_tdm_pp_done_handler, NULL);
+ error = tdm_pp_attach(NULL, NULL, NULL);
ASSERT_NE(TDM_ERROR_NONE, error);
}
-TEST(tdm_pp_destroy, work_flow_success_1)
+TEST_F(TDMPP, PpAttachFailNullPp)
{
- tdm_private_pp *private_pp;
- tdm_pp_private_buffer *pp_buffer1;
- tdm_pp_private_buffer *pp_buffer2;
- tdm_private_display private_display;
- private_pp = (tdm_private_pp *)calloc(1, sizeof(tdm_private_pp));
- pp_buffer1 = (tdm_pp_private_buffer *)calloc(1, sizeof *pp_buffer1);
- pp_buffer2 = (tdm_pp_private_buffer *)calloc(1, sizeof *pp_buffer2);
-
- private_display.func_pp.pp_destroy = stub_pp_destroy;
- _init_test();
-
- LIST_INITHEAD(&private_display.pp_list);
- private_display.func_pp.pp_destroy = stub_pp_destroy;
- LIST_ADDTAIL(&private_pp->link, &private_display.pp_list);
-
-
- private_pp->private_display = &private_display;
- LIST_INITHEAD(&private_pp->pending_buffer_list);
- LIST_ADDTAIL(&pp_buffer1->link, &private_pp->pending_buffer_list);
+ SKIP_FLAG(has_pp);
+ tdm_error error;
+ tbm_surface_h dst_buf, src_buf;
- LIST_INITHEAD(&private_pp->buffer_list);
- LIST_ADDTAIL(&pp_buffer2->link, &private_pp->buffer_list);
+ src_buf = UtCreateBuffer(default_src_w, default_src_h, formats[0]);
+ ASSERT_NE(NULL, src_buf);
- tdm_pp_destroy(private_pp);
+ dst_buf = UtCreateBuffer(default_dst_w, default_dst_h, formats[0]);
+ ASSERT_NE(NULL, dst_buf);
- ASSERT_EQ(4, stub_tdm_buffer_unref_backend_count);
- ASSERT_EQ(3, stub_free_call_count);
- ASSERT_TRUE(stub_pp_destroy_is_called);
+ error = tdm_pp_attach(NULL, src_buf, dst_buf);
+ ASSERT_NE(TDM_ERROR_NONE, error);
}
-TEST(tdm_pp_destroy, work_flow_error_1___NULL)
+TEST_F(TDMPP, PpAttachFailNullSrc)
{
- tdm_pp_destroy(NULL);
-}
+ SKIP_FLAG(has_pp);
+ tdm_error error;
+ tbm_surface_h dst_buf;
-/* tdm_pp_create_internal() */
+ dst_buf = UtCreateBuffer(default_dst_w, default_dst_h, formats[0]);
+ ASSERT_NE(NULL, dst_buf);
-TEST(tdm_pp_create_internal, work_flow_success_1)
+ error = tdm_pp_attach(pp, NULL, dst_buf);
+ ASSERT_NE(TDM_ERROR_NONE, error);
+}
+
+TEST_F(TDMPP, PpAttachFailNullDst)
{
+ SKIP_FLAG(has_pp);
tdm_error error;
- tdm_private_display private_display;
- tdm_private_pp *private_pp_ret;
- tdm_private_pp private_pp;
+ tbm_surface_h src_buf;
- _init_test();
+ src_buf = UtCreateBuffer(default_src_w, default_src_h, formats[0]);
+ ASSERT_NE(NULL, src_buf);
- stub_tdm_helper_get_time_ret_val = 1.1;
-
- private_display.func_pp.pp_destroy = stub_pp_destroy;
- private_display.func_pp.pp_set_done_handler = stub_pp_set_done_handler;
- private_display.func_display.display_create_pp = stub_display_create_pp;
- private_display.capabilities = TDM_DISPLAY_CAPABILITY_PP;
- LIST_INITHEAD(&private_display.pp_list);
+ error = tdm_pp_attach(pp, src_buf, NULL);
+ ASSERT_NE(TDM_ERROR_NONE, error);
+}
- private_pp.stamp = stub_tdm_helper_get_time_ret_val;
+TEST_F(TDMPP, PpAttachSuccess)
+{
+ SKIP_FLAG(has_pp);
+ tdm_error error;
+ tbm_surface_h dst_buf, src_buf;
- LIST_ADD(&private_pp.link, &private_display.pp_list);
+ src_buf = UtCreateBuffer(default_src_w, default_src_h, formats[0]);
+ ASSERT_NE(NULL, src_buf);
- private_pp_ret = tdm_pp_create_internal(&private_display, &error);
+ dst_buf = UtCreateBuffer(default_dst_w, default_dst_h, formats[0]);
+ ASSERT_NE(NULL, dst_buf);
+ error = tdm_pp_attach(pp, src_buf, dst_buf);
ASSERT_EQ(TDM_ERROR_NONE, error);
- ASSERT_TRUE(stub_pp_set_done_handler_is_called);
- ASSERT_TRUE(stub_display_create_pp_is_called);
- ASSERT_TRUE(private_pp_ret != NULL);
}
-TEST(tdm_pp_create_internal, work_flow_error_1___TDM_DISPLAY_CAPABILITY_PP_is_not_set)
+/* tdm_pp_commit() */
+
+TEST_F(TDMPP, PpCommitFailNullPP)
{
+ SKIP_FLAG(has_pp);
tdm_error error;
- tdm_private_display private_display;
- tdm_private_pp *private_pp;
-
- _init_test();
- private_display.func_pp.pp_destroy = stub_pp_destroy;
- private_display.func_pp.pp_set_done_handler = stub_pp_set_done_handler;
- private_display.func_display.display_create_pp = stub_display_create_pp;
- private_display.capabilities = TDM_DISPLAY_CAPABILITY_PP;
- LIST_INITHEAD(&private_display.pp_list);
+ error = tdm_pp_commit(NULL);
+ ASSERT_NE(TDM_ERROR_NONE, error);
+}
+TEST_F(TDMPPCommit, PpCommitFailWrongInfo)
+{
+ SKIP_FLAG(has_pp);
+ tdm_error error;
- private_display.capabilities = (tdm_display_capability)0;
+ ASSERT_NE(-1, UtPrepareToPPWithWrongInfo());
- private_pp = tdm_pp_create_internal(&private_display, &error);
+ error = tdm_pp_commit(pp);
ASSERT_NE(TDM_ERROR_NONE, error);
- ASSERT_TRUE(private_pp == NULL);
}
-TEST(tdm_pp_create_internal, work_flow_error_1___calloc_error)
+TEST_F(TDMPPCommit, PpCommitSuccessScale)
{
+ SKIP_FLAG(has_pp);
tdm_error error;
- tdm_private_display private_display;
- tdm_private_pp *private_pp;
- _init_test();
+ ASSERT_NE(-1, UtPrepareToPPWithScale());
- private_display.func_pp.pp_destroy = stub_pp_destroy;
- private_display.func_pp.pp_set_done_handler = stub_pp_set_done_handler;
- private_display.func_display.display_create_pp = stub_display_create_pp;
- private_display.capabilities = TDM_DISPLAY_CAPABILITY_PP;
- LIST_INITHEAD(&private_display.pp_list);
+ error = tdm_pp_commit(pp);
+ ASSERT_EQ(TDM_ERROR_NONE, error);
- CALLOC_ERROR = 1;
+ UtHandlePPEvent(1);
- private_pp = tdm_pp_create_internal(&private_display, &error);
- ASSERT_NE(TDM_ERROR_NONE, error);
- ASSERT_TRUE(private_pp == NULL);
+ ASSERT_EQ(1, utPpDoneHandlerSuccessCounter);
}
-TEST(tdm_pp_create_internal, work_flow_error_1___create_pp_error)
+TEST_F(TDMPPCommit, PpCommitSuccessScaleAndTransform)
{
+ SKIP_FLAG(has_pp);
tdm_error error;
- tdm_private_display private_display;
- tdm_private_pp *private_pp;
- _init_test();
+ ASSERT_NE(-1, UtPrepareToPPWithScale());
- stub_display_create_pp_error = 1;
- private_display.func_display.display_create_pp = stub_display_create_pp;
- private_display.capabilities = TDM_DISPLAY_CAPABILITY_PP;
+ error = tdm_pp_commit(pp);
+ ASSERT_EQ(TDM_ERROR_NONE, error);
- private_pp = tdm_pp_create_internal(&private_display, &error);
- ASSERT_NE(TDM_ERROR_NONE, error);
- ASSERT_TRUE(private_pp == NULL);
+ UtHandlePPEvent(1);
+
+ ASSERT_EQ(1, utPpDoneHandlerSuccessCounter);
}
-TEST(tdm_pp_create_internal, work_flow_error_1___set_done_handler_error)
+TEST_F(TDMPPCommitThread, PpCommitSuccessScale)
{
+ SKIP_FLAG(has_pp);
tdm_error error;
- tdm_private_display private_display;
- tdm_private_pp *private_pp;
- _init_test();
+ ASSERT_NE(-1, UtPrepareToPPWithScale());
- stub_pp_set_done_handler_error = 1;
+ error = tdm_pp_commit(pp);
+ ASSERT_EQ(TDM_ERROR_NONE, error);
- private_display.func_pp.pp_destroy = stub_pp_destroy;
- private_display.func_pp.pp_set_done_handler = stub_pp_set_done_handler;
- private_display.func_display.display_create_pp = stub_display_create_pp;
- private_display.capabilities = TDM_DISPLAY_CAPABILITY_PP;
- LIST_INITHEAD(&private_display.pp_list);
+ UtHandlePPEvent(1);
- private_pp = tdm_pp_create_internal(&private_display, &error);
- ASSERT_NE(TDM_ERROR_NONE, error);
- ASSERT_TRUE(private_pp == NULL);
+ ASSERT_EQ(1, utPpDoneHandlerSuccessCounter);
}
-/* tdm_pp_cb_done() */
-
-TEST(tdm_pp_cb_done, success_not_in_display_thread)
+TEST_F(TDMPPCommitThread, PpCommitSuccessScaleAndTransform)
{
- tdm_private_pp private_pp;
- struct _tbm_surface src, dst;
- tdm_thread_cb_pp_done *pp_done;
-
- _init_test();
+ SKIP_FLAG(has_pp);
+ tdm_error error;
- stub_syscall_return_value = 100;
- private_pp.owner_tid = stub_syscall_return_value + 1;
- private_pp.stamp = 200.05;
+ ASSERT_NE(-1, UtPrepareToPPWithScale());
- tdm_pp_cb_done(&private_pp, &src, &dst, &private_pp);
+ error = tdm_pp_commit(pp);
+ ASSERT_EQ(TDM_ERROR_NONE, error);
- pp_done = (tdm_thread_cb_pp_done *)stub_tdm_thread_send_cb_buff;
+ UtHandlePPEvent(1);
- ASSERT_EQ(pp_done->base.type, TDM_THREAD_CB_PP_DONE);
- ASSERT_EQ(pp_done->base.length, sizeof * pp_done);
- ASSERT_DOUBLE_EQ(pp_done->pp_stamp, private_pp.stamp);
- ASSERT_TRUE(pp_done->src == &src);
- ASSERT_TRUE(pp_done->dst == &dst);
- ASSERT_TRUE(pp_done->user_data == &private_pp);
+ ASSERT_EQ(1, utPpDoneHandlerSuccessCounter);
}
-//TEST(tdm_pp_cb_done, success_in_display_thread)
-//{
-// tdm_private_pp private_pp;
-// struct _tbm_surface src, dst;
-// tdm_pp_private_buffer *pp_buffer_1;
-// tdm_pp_private_buffer *pp_buffer_2;
-//
-// _init_test();
-//
-// stub_syscall_return_value = 100;
-// stub_syscall_reset = 1;
-// private_pp.owner_tid = stub_syscall_return_value;
-//
-// pp_buffer_1 = (tdm_pp_private_buffer *)calloc(1, sizeof (tdm_pp_private_buffer));
-// pp_buffer_2 = (tdm_pp_private_buffer *)calloc(1, sizeof (tdm_pp_private_buffer));
-// pp_buffer_1->src = &src;
-// pp_buffer_1->dst = &dst;
-// private_pp.done_func = stub_tdm_pp_done_handler;
-//
-// LIST_INITHEAD(&private_pp.buffer_list);
-// LIST_ADD(&pp_buffer_1->link, &private_pp.buffer_list);
-// LIST_ADD(&pp_buffer_2->link, &private_pp.buffer_list);
-//
-// tdm_pp_cb_done(&private_pp, &src, &dst, &private_pp);
-//
-// ASSERT_EQ(stub_tdm_buffer_unref_backend_count, 2);
-// ASSERT_EQ(FREE_CALLED, 1);
-// ASSERT_EQ(stub_tdm_pp_done_handler_is_called, 1);
-// free(pp_buffer_2);
-//}
-
-/* tdm_pp_find_stamp() */
-
-TEST(tdm_pp_find_stamp, success_pp_list_is_empty)
-{
- tdm_private_pp *private_pp_ret;
- tdm_private_display private_display;
-
- _init_test();
-
- LIST_INITHEAD(&private_display.pp_list);
+/* tdm_pp_destroy() */
- private_pp_ret = tdm_pp_find_stamp(&private_display, 0.5);
+void UtBufferReleaseHandler(tbm_surface_h buffer,
+ void *user_data)
+{
+ int *data = (int *)user_data;
+ if (!data)
+ return;
- ASSERT_TRUE(private_pp_ret == NULL);
+ (*data)++;
}
-TEST(tdm_pp_find_stamp, success_pp_find_stamp)
+TEST_F(TDMPPCommit, PPDestroySuccessAfterCommit)
{
- tdm_private_pp *private_pp_ret;
- tdm_private_display private_display;
- tdm_private_pp private_pp;
- double stamp = 12.25;
+ SKIP_FLAG(has_pp);
+ tdm_error error;
+ int release_data = 0;
- _init_test();
+ ASSERT_NE(-1, UtPrepareToPPWithScale());
- LIST_INITHEAD(&private_display.pp_list);
- LIST_ADD(&private_pp.link, &private_display.pp_list);
+ for (auto it = buffers_list.begin(); it != buffers_list.end(); ++it) {
+ tdm_buffer_add_release_handler((tbm_surface_h)*it, UtBufferReleaseHandler, &release_data);
+ }
- private_pp.stamp = stamp;
+ error = tdm_pp_commit(pp);
+ ASSERT_EQ(TDM_ERROR_NONE, error);
- private_pp_ret = tdm_pp_find_stamp(&private_display, stamp);
+ tdm_pp_destroy(pp);
+ pp = NULL;
- ASSERT_TRUE(private_pp_ret == &private_pp);
+ ASSERT_EQ(2, release_data);
}
projects / platform / core / uifw / libtdm.git / blobdiff