ut: improve code coverage of tdm_helper.c

Change-Id: I40ed5e701b721fb792562e33a75c371da144e6c5
Signed-off-by: Roman Marchenko <r.marchenko@samsung.com>
Signed-off-by: SooChan Lim <sc1.lim@samsung.com>

diff --git a/ut/Makefile.am b/ut/Makefile.am
index b8e002f..56cd18e 100644 (file)
--- a/ut/Makefile.am
+++ b/ut/Makefile.am
@@ -16,6 +16,7 @@ tdm_utests_SOURCES = \
        stubs/tdm_log.cpp \
        stubs/tdm_server.cpp \
        stubs/stub_pthread.cpp \
+       stubs/stub_dlfcn.cpp \
        stubs/stub_stdlib.cpp \
        stubs/tdm_backend_module_subs.cpp \
        stubs/stub_unistd.cpp \

diff --git a/ut/src/ut_tdm_helper.cpp b/ut/src/ut_tdm_helper.cpp
index 098da6f..0f6fcdf 100644 (file)
--- a/ut/src/ut_tdm_helper.cpp
+++ b/ut/src/ut_tdm_helper.cpp
@@ -27,13 +27,22 @@
 **************************************************************************/
 
 #include "gtest/gtest.h"
+#include <png.h>
 
+/*------ stubs -----------------*/
 #include "tbm_stubs.h"
 #include "stub_pthread.h"
 #include "stub_stdlib.h"
 #include "stub_unistd.h"
 #include "stub_fcntl.h"
+#include "stub_dlfcn.h"
 #include "stub_stdio.h"
+#include "tdm_event_loop_stubs.h"
+
+#define png_write_info(p1, p2)
+#define png_write_image(p1, p2)
+#define png_write_end(p1, p2)
+/*------ stubs ----------------*/
 
 #pragma GCC optimize(0)
 
@@ -136,3 +145,615 @@ TEST(tdm_helper_get_fd, work_flow_success_1)
 
        ASSERT_EQ(fd, expected_fd);
 }
+
+/* tdm_helper_set_fd */
+TEST(tdm_helper_set_fd, work_flow_success_1)
+{
+       _init_test();
+       tdm_helper_set_fd("TEST_ENV", 7);
+
+       ASSERT_STREQ(stub_getenv_name, "TEST_ENV");
+}
+
+TEST(tdm_helper_set_fd, work_flow_error_1__setenv_error)
+{
+       _init_test();
+       SETENV_ERROR = 1;
+
+       tdm_helper_set_fd("TEST_ENV", 7);
+
+       ASSERT_EQ(stub_getenv_name, 0);
+       ASSERT_EQ(stub_getenv_return_value, 0);
+}
+
+/* tdm_helper_dump_start */
+TEST(tdm_helper_dump_start, work_flow_success_1)
+{
+       _init_test();
+       int count = 0;
+       tdm_dump_enable = 0;
+       tdm_helper_dump_start("test_str1", &count);
+       ASSERT_EQ(tdm_dump_enable, 1);
+}
+
+TEST(tdm_helper_dump_start, work_flow_error_1__NULL)
+{
+       _init_test();
+       int count = 0;
+       tdm_dump_enable = 0;
+       tdm_helper_dump_start("test_str1", NULL);
+       ASSERT_EQ(tdm_dump_enable, 0);
+       tdm_helper_dump_start(NULL, &count);
+       ASSERT_EQ(tdm_dump_enable, 0);
+}
+
+/* tdm_helper_dump_start */
+TEST(tdm_helper_dump_stop, work_flow_success_1)
+{
+       _init_test();
+       tdm_dump_enable = 0;
+       tdm_helper_dump_stop();
+       ASSERT_EQ(tdm_dump_enable, 0);
+}
+
+tdm_error stub_output_get_mode(tdm_output *output, const tdm_output_mode **mode)
+{
+       static tdm_output_mode cmode;
+       *mode = &cmode;
+       return TDM_ERROR_NONE;
+}
+
+tdm_error stub_output_get_property(tdm_output *output, unsigned int id, tdm_value *value)
+{
+       (tdm_output *)output;
+       (unsigned int)id;
+       value->s32 = 1;
+       return TDM_ERROR_NONE;
+}
+
+tdm_error stub_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
+{
+       (tdm_layer *)layer;
+       (unsigned int)id;
+       value->s32 = 1;
+       return TDM_ERROR_NONE;
+}
+
+tdm_error stub_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
+{
+       (tdm_layer *)layer;
+       (tdm_info_layer *)info;
+       return TDM_ERROR_NONE;
+}
+
+
+/* tdm_helper_get_display_information */
+TEST(tdm_helper_get_display_information, work_flow_success_1)
+{
+       tdm_private_display disp;
+       tdm_backend_module module;
+       tdm_private_output output;
+       tdm_private_layer layer;
+       tdm_private_pp pp;
+       tdm_private_capture capture;
+       tdm_output_mode output_mode;
+       tdm_prop prop;
+       tdm_info_layer info;
+       tdm_private_display *private_display = &disp;
+       tbm_format formats[2] = {TBM_FORMAT_ABGR8888, 0};
+
+       memset(&disp, 0, sizeof(disp));
+       memset(&module, 0, sizeof(module));
+       memset(&output, 0, sizeof(output));
+       memset(&layer, 0, sizeof(layer));
+       memset(&pp, 0, sizeof(pp));
+       memset(&capture, 0, sizeof(capture));
+       memset(&output_mode, 0, sizeof(output_mode));
+       memset(&prop, 0, sizeof(prop));
+       memset(&info, 0, sizeof(info));
+
+       int  len = 1024;
+       char rep[len];
+
+       _init_test();
+
+       //init disp
+       private_display->capabilities =  TDM_DISPLAY_CAPABILITY_PP | TDM_DISPLAY_CAPABILITY_CAPTURE;
+       LIST_INITHEAD(&private_display->output_list);
+       LIST_INITHEAD(&private_display->pp_list);
+       LIST_INITHEAD(&private_display->capture_list);
+
+       //init module
+       private_display->module_data = &module;
+       module.abi_version = 0x00010001;
+       module.name = "test";
+       module.vendor = "test";
+
+       //init output
+       LIST_ADDTAIL(&output.link, &private_display->output_list);
+       LIST_INITHEAD(&output.capture_list);
+       LIST_INITHEAD(&output.layer_list);
+       output.caps.mode_count = 1;
+       output.caps.modes = &output_mode;
+       output.caps.prop_count = 1;
+       output.caps.props = &prop;
+       memset(&output_mode, 0, sizeof(output_mode));
+       private_display->func_output.output_get_mode = stub_output_get_mode;
+       private_display->func_output.output_get_property = stub_output_get_property;
+
+       //init layer
+       LIST_ADDTAIL(&layer.link, &output.layer_list);
+       layer.usable = 0;
+       layer.caps.format_count = 2;
+       layer.caps.formats = formats;
+       layer.caps.prop_count = 1;
+       layer.caps.props = &prop;
+       private_display->func_layer.layer_get_info = stub_layer_get_info;
+       private_display->func_layer.layer_get_property = stub_layer_get_property;
+
+       //init pp
+       LIST_ADDTAIL(&pp.link, &private_display->pp_list);
+       private_display->caps_pp.format_count = 2;
+       private_display->caps_pp.formats = formats;
+
+       //init capture
+       LIST_ADDTAIL(&capture.link, &private_display->capture_list);
+       private_display->caps_capture.format_count = 2;
+       private_display->caps_capture.formats = formats;
+
+       tdm_helper_get_display_information(private_display, rep, &len);
+}
+
+static int stub_tdm_helper_capture_handler_is_called = 0;
+static void stub_tdm_helper_capture_handler(tbm_surface_h buffer, void *user_data)
+{
+       stub_tdm_helper_capture_handler_is_called = 1;
+}
+
+/* tdm_helper_capture_output */
+TEST(tdm_helper_capture_output, work_flow_success_1)
+{
+       tdm_error error;
+       tdm_private_display display;
+       tdm_private_output output;
+       tdm_private_layer layer;
+       int src_mem[100][100];
+       int dst_mem[100][100];
+       struct _tbm_surface src_surface;
+       struct _tbm_surface dst_surface;
+       memset(&output, 0, sizeof(output));
+       memset(&layer, 0, sizeof(layer));
+
+       src_surface.info.format = TBM_FORMAT_ARGB8888;
+       src_surface.info.width = 100;
+       src_surface.info.height = 100;
+       src_surface.info.num_planes = 1;
+       src_surface.info.planes[0].ptr = (unsigned char*)src_mem;
+       src_surface.info.planes[0].stride = src_surface.info.width * 4;
+
+       dst_surface.info.format = TBM_FORMAT_XRGB8888;
+       dst_surface.info.width = 100;
+       dst_surface.info.height = 100;
+       dst_surface.info.num_planes = 1;
+       dst_surface.info.planes[0].ptr = (unsigned char*)dst_mem;
+       dst_surface.info.planes[0].stride = dst_surface.info.width * 4;
+
+       _init_test();
+
+       //init output
+       LIST_INITHEAD(&output.layer_list);
+       LIST_ADDTAIL(&layer.link, &output.layer_list);
+       output.private_display = &display;
+       layer.showing_buffer = (tbm_surface_h)&src_surface;
+       layer.private_output = &output;
+       layer.private_display = &display;
+
+
+       error = tdm_helper_capture_output(&output, (tbm_surface_h)&dst_surface, 0, 0, 10, 10, stub_tdm_helper_capture_handler, &layer);
+
+       ASSERT_EQ(TDM_ERROR_NONE, error);
+       ASSERT_EQ(1, stub_tdm_helper_capture_handler_is_called);
+}
+
+TEST(tdm_helper_capture_output, work_flow_error_1___no_layer)
+{
+       tdm_error error;
+       tdm_private_display display;
+       tdm_private_output output;
+       tdm_private_layer layer;
+       int src_mem[100][100];
+       int dst_mem[100][100];
+       struct _tbm_surface src_surface;
+       struct _tbm_surface dst_surface;
+       memset(&output, 0, sizeof(output));
+       memset(&layer, 0, sizeof(layer));
+
+       src_surface.info.format = TBM_FORMAT_ARGB8888;
+       src_surface.info.width = 100;
+       src_surface.info.height = 100;
+       src_surface.info.num_planes = 1;
+       src_surface.info.planes[0].ptr = (unsigned char*)src_mem;
+       src_surface.info.planes[0].stride = src_surface.info.width * 4;
+
+       dst_surface.info.format = TBM_FORMAT_XRGB8888;
+       dst_surface.info.width = 100;
+       dst_surface.info.height = 100;
+       dst_surface.info.num_planes = 1;
+       dst_surface.info.planes[0].ptr = (unsigned char*)dst_mem;
+       dst_surface.info.planes[0].stride = dst_surface.info.width * 4;
+
+       _init_test();
+
+       //init output
+       LIST_INITHEAD(&output.layer_list);
+       output.private_display = &display;
+       layer.showing_buffer = (tbm_surface_h)&src_surface;
+       layer.private_output = &output;
+       layer.private_display = &display;
+
+
+       error = tdm_helper_capture_output(&output, (tbm_surface_h)&dst_surface, 0, 0, 10, 10, stub_tdm_helper_capture_handler, &layer);
+
+       ASSERT_NE(TDM_ERROR_NONE, error);
+}
+
+TEST(tdm_helper_capture_output, work_flow_error_2___wrong_buffer_format)
+{
+       tdm_error error;
+       tdm_private_display display;
+       tdm_private_output output;
+       tdm_private_layer layer;
+       int src_mem[100][100];
+       int dst_mem[100][100];
+       struct _tbm_surface src_surface;
+       struct _tbm_surface dst_surface;
+       memset(&output, 0, sizeof(output));
+       memset(&layer, 0, sizeof(layer));
+
+       src_surface.info.format = TBM_FORMAT_XRGB8888;
+       src_surface.info.width = 100;
+       src_surface.info.height = 100;
+       src_surface.info.num_planes = 1;
+       src_surface.info.planes[0].ptr = (unsigned char*)src_mem;
+       src_surface.info.planes[0].stride = src_surface.info.width * 4;
+
+       src_surface.info.format = TBM_FORMAT_XRGB8888;
+       dst_surface.info.width = 100;
+       dst_surface.info.height = 100;
+       dst_surface.info.num_planes = 1;
+       dst_surface.info.planes[0].ptr = (unsigned char*)dst_mem;
+       dst_surface.info.planes[0].stride = dst_surface.info.width * 4;
+
+       _init_test();
+
+       //init output
+       LIST_INITHEAD(&output.layer_list);
+       LIST_ADDTAIL(&layer.link, &output.layer_list);
+       output.private_display = &display;
+       layer.showing_buffer = (tbm_surface_h)&src_surface;
+       layer.private_output = &output;
+       layer.private_display = &display;
+
+       dst_surface.info.format = TBM_FORMAT_YUV410;
+       error = tdm_helper_capture_output(&output, (tbm_surface_h)&dst_surface, 0, 0, 10, 10, stub_tdm_helper_capture_handler, &layer);
+       ASSERT_EQ(TDM_ERROR_NONE, error);
+}
+
+TEST(tdm_helper_capture_output, work_flow_error_2___tbm_surface_map)
+{
+       tdm_error error;
+       tdm_private_display display;
+       tdm_private_output output;
+       tdm_private_layer layer;
+       int src_mem[100][100];
+       int dst_mem[100][100];
+       struct _tbm_surface src_surface;
+       struct _tbm_surface dst_surface;
+       memset(&output, 0, sizeof(output));
+       memset(&layer, 0, sizeof(layer));
+
+       src_surface.info.format = TBM_FORMAT_ARGB8888;
+       src_surface.info.width = 100;
+       src_surface.info.height = 100;
+       src_surface.info.num_planes = 1;
+       src_surface.info.planes[0].ptr = (unsigned char*)src_mem;
+       src_surface.info.planes[0].stride = src_surface.info.width * 4;
+
+       dst_surface.info.format = TBM_FORMAT_XRGB8888;
+       dst_surface.info.width = 100;
+       dst_surface.info.height = 100;
+       dst_surface.info.num_planes = 1;
+       dst_surface.info.planes[0].ptr = (unsigned char*)dst_mem;
+       dst_surface.info.planes[0].stride = dst_surface.info.width * 4;
+
+       _init_test();
+
+       //init output
+       LIST_INITHEAD(&output.layer_list);
+       LIST_ADDTAIL(&layer.link, &output.layer_list);
+       output.private_display = &display;
+       layer.showing_buffer = (tbm_surface_h)&src_surface;
+       layer.private_output = &output;
+       layer.private_display = &display;
+
+
+       dst_surface.info.num_planes = 0;
+       error = tdm_helper_capture_output(&output, (tbm_surface_h)&dst_surface, 0, 0, 10, 10, stub_tdm_helper_capture_handler, &layer);
+       ASSERT_EQ(TDM_ERROR_NONE, error);
+       dst_surface.info.num_planes = 1;
+
+       src_surface.info.num_planes = 0;
+       error = tdm_helper_capture_output(&output, (tbm_surface_h)&dst_surface, 0, 0, 10, 10, stub_tdm_helper_capture_handler, &layer);
+       ASSERT_EQ(TDM_ERROR_NONE, error);
+}
+
+/* tdm_helper_convert_buffer */
+TEST(tdm_helper_convert_buffer, work_flow_success_1)
+{
+       tdm_error error;
+       int src_mem[100][100];
+       int dst_mem[100][100];
+       struct _tbm_surface src_surface;
+       struct _tbm_surface dst_surface;
+       tdm_pos src_pos = {0, 0, 100, 100};
+       tdm_pos dst_pos = {0, 0, 100, 100};
+
+       src_surface.info.format = TBM_FORMAT_ARGB8888;
+       src_surface.info.width = 100;
+       src_surface.info.height = 100;
+       src_surface.info.num_planes = 1;
+       src_surface.info.planes[0].ptr = (unsigned char*)src_mem;
+       src_surface.info.planes[0].stride = src_surface.info.width * 4;
+
+       dst_surface.info.format = TBM_FORMAT_XRGB8888;
+       dst_surface.info.width = 100;
+       dst_surface.info.height = 100;
+       dst_surface.info.num_planes = 1;
+       dst_surface.info.planes[0].ptr = (unsigned char*)dst_mem;
+       dst_surface.info.planes[0].stride = dst_surface.info.width * 4;
+
+       _init_test();
+
+       error = tdm_helper_convert_buffer(&src_surface, &dst_surface, &src_pos, &dst_pos, TDM_TRANSFORM_FLIPPED, 0);
+       ASSERT_EQ(TDM_ERROR_NONE, error);
+
+       error = tdm_helper_convert_buffer(&src_surface, &dst_surface, &src_pos, &dst_pos, TDM_TRANSFORM_90, 0);
+       ASSERT_EQ(TDM_ERROR_NONE, error);
+
+       error = tdm_helper_convert_buffer(&src_surface, &dst_surface, &src_pos, &dst_pos, TDM_TRANSFORM_180, 0);
+       ASSERT_EQ(TDM_ERROR_NONE, error);
+
+       error = tdm_helper_convert_buffer(&src_surface, &dst_surface, &src_pos, &dst_pos, TDM_TRANSFORM_FLIPPED_270, 0);
+       ASSERT_EQ(TDM_ERROR_NONE, error);
+}
+
+
+TEST(tdm_helper_convert_buffer, work_flow_error_1__NULL)
+{
+       tdm_error error;
+       int src_mem[100][100];
+       int dst_mem[100][100];
+       struct _tbm_surface src_surface;
+       struct _tbm_surface dst_surface;
+       tdm_pos src_pos = {0, 0, 100, 100};
+       tdm_pos dst_pos = {0, 0, 100, 100};
+
+       src_surface.info.format = TBM_FORMAT_ARGB8888;
+       src_surface.info.width = 100;
+       src_surface.info.height = 100;
+       src_surface.info.num_planes = 1;
+       src_surface.info.planes[0].ptr = (unsigned char*)src_mem;
+       src_surface.info.planes[0].stride = src_surface.info.width * 4;
+
+       dst_surface.info.format = TBM_FORMAT_XRGB8888;
+       dst_surface.info.width = 100;
+       dst_surface.info.height = 100;
+       dst_surface.info.num_planes = 1;
+       dst_surface.info.planes[0].ptr = (unsigned char*)dst_mem;
+       dst_surface.info.planes[0].stride = dst_surface.info.width * 4;
+
+       _init_test();
+       error = tdm_helper_convert_buffer(NULL, &dst_surface, &src_pos, &dst_pos, TDM_TRANSFORM_FLIPPED, 0);
+       ASSERT_NE(TDM_ERROR_NONE, error);
+       error = tdm_helper_convert_buffer(&src_surface, NULL, &src_pos, &dst_pos, TDM_TRANSFORM_FLIPPED, 0);
+       ASSERT_NE(TDM_ERROR_NONE, error);
+}
+
+TEST(tdm_helper_convert_buffer, work_flow_error_1___wrong_buffers)
+{
+       tdm_error error;
+       int src_mem[100][100];
+       int dst_mem[100][100];
+       struct _tbm_surface src_surface;
+       struct _tbm_surface dst_surface;
+       tdm_pos src_pos = {0, 0, 100, 100};
+       tdm_pos dst_pos = {0, 0, 100, 100};
+
+       src_surface.info.format = TBM_FORMAT_ARGB8888;
+       src_surface.info.width = 100;
+       src_surface.info.height = 100;
+       src_surface.info.num_planes = 1;
+       src_surface.info.planes[0].ptr = (unsigned char*)src_mem;
+       src_surface.info.planes[0].stride = src_surface.info.width * 4;
+
+       dst_surface.info.format = TBM_FORMAT_XRGB8888;
+       dst_surface.info.width = 100;
+       dst_surface.info.height = 100;
+       dst_surface.info.num_planes = 1;
+       dst_surface.info.planes[0].ptr = (unsigned char*)dst_mem;
+       dst_surface.info.planes[0].stride = dst_surface.info.width * 4;
+
+       _init_test();
+
+       //fail map of src buffer
+       src_surface.info.num_planes = 0;
+       error = tdm_helper_convert_buffer(&src_surface, &dst_surface, &src_pos, &dst_pos, TDM_TRANSFORM_FLIPPED, 0);
+       ASSERT_NE(TDM_ERROR_NONE, error);
+       src_surface.info.num_planes = 1;
+
+       //fail map of dst buffer
+       dst_surface.info.num_planes = 0;
+       error = tdm_helper_convert_buffer(&src_surface, &dst_surface, &src_pos, &dst_pos, TDM_TRANSFORM_FLIPPED, 0);
+       ASSERT_NE(TDM_ERROR_NONE, error);
+       dst_surface.info.num_planes = 1;
+
+       //wrong format of src buffer
+       src_surface.info.format = TBM_FORMAT_YUV410;
+       error = tdm_helper_convert_buffer(&src_surface, &dst_surface, &src_pos, &dst_pos, TDM_TRANSFORM_FLIPPED, 0);
+       ASSERT_NE(TDM_ERROR_NONE, error);
+       src_surface.info.format = TBM_FORMAT_ARGB8888;
+
+       //wrong format of dst buffer
+       dst_surface.info.format = TBM_FORMAT_YUV410;
+       error = tdm_helper_convert_buffer(&src_surface, &dst_surface, &src_pos, &dst_pos, TDM_TRANSFORM_FLIPPED, 0);
+       ASSERT_NE(TDM_ERROR_NONE, error);
+       dst_surface.info.format = TBM_FORMAT_ARGB8888;
+}
+
+
+/* tdm_helper_clear_buffer_pos */
+TEST(tdm_helper_clear_buffer_pos, work_flow_success_1)
+{
+       int mem1[100*100*3];
+       int mem2[100*100*3];
+       int mem3[100*100*3];
+       struct _tbm_surface surface;
+       tdm_pos pos = {1, 0, 9, 10};
+
+       surface.info.width = 10;
+       surface.info.height = 10;
+       surface.info.num_planes = 1;
+       surface.info.planes[0].ptr = (unsigned char*)mem1;
+       surface.info.planes[0].stride = surface.info.width * 4;
+       surface.info.planes[1].ptr = (unsigned char*)mem2;
+       surface.info.planes[1].stride = surface.info.width * 4;
+       surface.info.planes[2].ptr = (unsigned char*)mem3;
+       surface.info.planes[2].stride = surface.info.width * 4;
+
+       _init_test();
+
+       surface.info.format = TBM_FORMAT_ARGB8888;
+       memset(mem1, 0x77, sizeof(mem1));
+       memset(mem2, 0x77, sizeof(mem2));
+       memset(mem3, 0x77, sizeof(mem3));
+       tdm_helper_clear_buffer_pos(&surface, &pos);
+       EXPECT_EQ(0, mem1[100+1]);
+       EXPECT_EQ(0x77777777, mem1[0]);
+       EXPECT_EQ(0x77777777, mem2[0]);
+       EXPECT_EQ(0x77777777, mem3[0]);
+
+
+       surface.info.format = TBM_FORMAT_YVU420;
+       memset(mem1, 0x77, sizeof(mem1));
+       memset(mem2, 0x77, sizeof(mem2));
+       memset(mem3, 0x77, sizeof(mem3));
+       tdm_helper_clear_buffer_pos(&surface, NULL);
+       EXPECT_EQ(0x10101010, mem1[0]);
+       EXPECT_EQ(0x80808080, mem2[0]);
+       EXPECT_EQ(0x80808080, mem3[0]);
+
+       surface.info.format = TBM_FORMAT_NV12;
+       memset(mem1, 0x77, sizeof(mem1));
+       memset(mem2, 0x77, sizeof(mem2));
+       memset(mem3, 0x77, sizeof(mem3));
+       tdm_helper_clear_buffer_pos(&surface, NULL);
+       EXPECT_EQ(0x10101010, mem1[0]);
+       EXPECT_EQ(0x80808080, mem2[0]);
+       EXPECT_EQ(0x77777777, mem3[0]);
+
+       surface.info.format = TBM_FORMAT_UYVY;
+       memset(mem2, 0x77, sizeof(mem2));
+       memset(mem3, 0x77, sizeof(mem3));
+       tdm_helper_clear_buffer_pos(&surface, NULL);
+       EXPECT_EQ(0x80108010, mem1[0]);
+       EXPECT_EQ(0x77777777, mem2[0]);
+       EXPECT_EQ(0x77777777, mem3[0]);
+
+       surface.info.format = TBM_FORMAT_YUYV;
+       memset(mem1, 0x77, sizeof(mem1));
+       memset(mem2, 0x77, sizeof(mem2));
+       memset(mem3, 0x77, sizeof(mem3));
+       tdm_helper_clear_buffer_pos(&surface, NULL);
+       EXPECT_EQ(0x10801080, mem1[0]);
+       EXPECT_EQ(0x77777777, mem2[0]);
+       EXPECT_EQ(0x77777777, mem3[0]);
+
+       surface.info.format = TBM_FORMAT_YVU411;
+       memset(mem1, 0x77, sizeof(mem1));
+       memset(mem2, 0x77, sizeof(mem2));
+       memset(mem3, 0x77, sizeof(mem3));
+       tdm_helper_clear_buffer_pos(&surface, NULL);
+       EXPECT_EQ(0x77777777, mem1[0]);
+       EXPECT_EQ(0x77777777, mem2[0]);
+       EXPECT_EQ(0x77777777, mem3[0]);
+}
+
+
+/* tdm_helper_clear_buffer */
+TEST(tdm_helper_clear_buffer, work_flow_success_1)
+{
+       int mem1[100*100*3];
+       struct _tbm_surface surface;
+
+       surface.info.width = 10;
+       surface.info.height = 10;
+       surface.info.num_planes = 1;
+       surface.info.planes[0].ptr = (unsigned char*)mem1;
+       surface.info.planes[0].stride = surface.info.width * 4;
+
+       _init_test();
+
+       surface.info.format = TBM_FORMAT_ARGB8888;
+       memset(mem1, 0x77, sizeof(mem1));
+       tdm_helper_clear_buffer(&surface);
+       EXPECT_EQ(0, mem1[0]);
+}
+
+/* tdm_helper_dump_buffer */
+TEST(tdm_helper_dump_buffer, work_flow_success_1)
+{
+       int mem1[10*10*3];
+       int mem2[10*10*3];
+       int mem3[10*10*3];
+       struct _tbm_surface surface;
+
+       surface.info.width = 10;
+       surface.info.height = 10;
+       surface.info.num_planes = 1;
+       surface.info.planes[0].ptr = (unsigned char*)mem1;
+       surface.info.planes[0].stride = surface.info.width * 4;
+       surface.info.planes[1].ptr = (unsigned char*)mem2;
+       surface.info.planes[1].stride = surface.info.width * 4;
+       surface.info.planes[2].ptr = (unsigned char*)mem3;
+       surface.info.planes[2].stride = surface.info.width * 4;
+
+       _init_test();
+
+       surface.info.format = TBM_FORMAT_ARGB8888;
+       tdm_helper_dump_buffer(&surface, "tmp.png");
+
+       surface.info.format = TBM_FORMAT_YVU420;
+       tdm_helper_dump_buffer(&surface, "tmp.yuv");
+
+       surface.info.format = TBM_FORMAT_NV12;
+       tdm_helper_dump_buffer(&surface, "tmp.yuv");
+
+       surface.info.format = TBM_FORMAT_YUYV;
+       tdm_helper_dump_buffer(&surface, "tmp.yuv");
+
+       surface.info.format = TBM_FORMAT_YVU411;
+       tdm_helper_dump_buffer(&surface, "tmp.yuv");
+}
+
+/* tdm_helper_dump_buffer */
+TEST(tdm_helper_dump_buffer, work_flow_error_1___NULL)
+{
+       struct _tbm_surface surface;
+       char str[1024] = {'t', 'm', 'p', 0};
+
+       _init_test();
+
+       tdm_helper_dump_buffer(&surface, "tmp.yuv");
+       tdm_helper_dump_buffer(NULL, str);
+}
+

diff --git a/ut/stubs/stub_dlfcn.cpp b/ut/stubs/stub_dlfcn.cpp
new file mode 100644 (file)
index 0000000..7d7d964
--- /dev/null
+++ b/ut/stubs/stub_dlfcn.cpp
@@ -0,0 +1,26 @@
+#define STUB_DLFCN_IMPL
+#include "stub_dlfcn.h"
+
+struct _dlfcn_stub_ctrl stub_dlfcn_ctrl;
+
+void stub_dlfcn_init()
+{
+       stub_dlfcn_ctrl.dlsym_returned_val = 0;
+       stub_dlfcn_ctrl.dlopen_returned_val = 0;
+}
+
+void *stub_dlopen(const char *file, int mode)
+{
+       return stub_dlfcn_ctrl.dlopen_returned_val;
+}
+
+int stub_dlclose(void * handle)
+{
+       return 0;
+}
+
+void *stub_dlsym(void *handle, const char *name)
+{
+       return stub_dlfcn_ctrl.dlsym_returned_val;
+}
+

diff --git a/ut/stubs/stub_dlfcn.h b/ut/stubs/stub_dlfcn.h
index 9060aa3..ef7a473 100644 (file)
--- a/ut/stubs/stub_dlfcn.h
+++ b/ut/stubs/stub_dlfcn.h
@@ -3,42 +3,23 @@
 
 #include <dlfcn.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-static struct _dlfcn_stub_ctrl {
+struct _dlfcn_stub_ctrl {
        void* dlsym_returned_val;
        void* dlopen_returned_val;
-} stub_dlfcn_ctrl;
-
-static void stub_dlfcn_init()
-{
-       stub_dlfcn_ctrl.dlsym_returned_val = 0;
-       stub_dlfcn_ctrl.dlopen_returned_val = 0;
-}
-
-static void *ut_dlopen (const char *__file, int __mode)
-{
-       return stub_dlfcn_ctrl.dlopen_returned_val;
-}
+};
 
-static int ut_dlclose (void *__handle)
-{
-       return 0;
-}
+extern struct _dlfcn_stub_ctrl stub_dlfcn_ctrl;
 
-static void *ut_dlsym (void *__restrict __handle, const char *__restrict __name)
-{
-       return stub_dlfcn_ctrl.dlsym_returned_val;
-}
+void stub_dlfcn_init();
 
-#define dlopen ut_dlopen
-#define dlclose ut_dlclose
-#define dlsym ut_dlsym
+void *stub_dlopen (const char * file, int mode);
+int stub_dlclose (void * handle);
+void *stub_dlsym (void * handle, const char *name);
 
-#ifdef __cplusplus
-}
+#ifndef STUB_DLFCN_IMPL
+       #define dlopen stub_dlopen
+       #define dlclose stub_dlclose
+       #define dlsym stub_dlsym
 #endif
 
 #endif /* _DLFCN_STUBS_H_ */

diff --git a/ut/stubs/stub_fcntl.h b/ut/stubs/stub_fcntl.h
index dd1124e..55a0fdc 100644 (file)
--- a/ut/stubs/stub_fcntl.h
+++ b/ut/stubs/stub_fcntl.h
@@ -3,7 +3,7 @@
 
 static int FCNTL_ERROR;
 
-static stub_fcntl_init()
+static void stub_fcntl_init()
 {
        FCNTL_ERROR = 0;
 }

diff --git a/ut/stubs/stub_stdio.h b/ut/stubs/stub_stdio.h
index 0c5e977..8f3144c 100644 (file)
--- a/ut/stubs/stub_stdio.h
+++ b/ut/stubs/stub_stdio.h
@@ -1,6 +1,8 @@
 #ifndef STUB_STDIO_H
 #define STUB_STDIO_H
 
+#include <stdio.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -44,18 +46,19 @@ static int stub_sscanf(const char *buf, const char *format, ...)
 #define O_CLOEXEC      02000000        /* copy from <bits/fcntl-linux.h>*/
 #endif
 
-static int stub_fopen (const char *__file, int __oflag, ...)
+static FILE *stub_fopen (const char *filename, const char *modes)
 {
-       if (__file == NULL)
-               return -1;
-       return open_close_stub_ctrl.fopen_fd_returned;
+       if (filename == NULL)
+               return NULL;
+       static FILE f;
+       return &f;
 }
 
-static int stub_fclose (int __fd)
+static int stub_fclose (FILE *__stream)
 {
        if (open_close_stub_ctrl.fclose_error)
                return -1;
-       if (__fd < 1)
+       if (__stream == NULL)
                return -1;
 
        open_close_stub_ctrl.fclose_colled = 1;
@@ -77,18 +80,22 @@ static int stub_setvbuf (FILE *__restrict __stream, char *__restrict __buf, int
        return 1;
 }
 
+static size_t stub_fwrite (const void * ptr, size_t size,
+                     size_t n, FILE *s)
+{
+       return size;
+}
+
 #ifdef open
        #undef open
 #endif
 #define fopen stub_fopen
 #define fclose stub_fclose
-#define close stub_close
 #define fflush stub_fflush
 #define fileno stub_fileno
 #define setvbuf stub_setvbuf
-#define dup stub_dup
-#define dup2 stub_dup2
 #define sscanf stub_sscanf
+#define fwrite stub_fwrite
 
 #ifdef __cplusplus
 }

diff --git a/ut/stubs/stub_stdlib.cpp b/ut/stubs/stub_stdlib.cpp
index f31cb5b..1369cd0 100644 (file)
--- a/ut/stubs/stub_stdlib.cpp
+++ b/ut/stubs/stub_stdlib.cpp
@@ -6,9 +6,11 @@ int CALLOC_ERROR;
 int CALLOC_RETURN_BUFFER;
 int FREE_CALLED;
 int GETENV_ERROR;
+int SETENV_ERROR;
 
 char *stub_getenv_return_value;
 int stub_getenv_return_real_value;
+int stub_setenv_real;
 char *stub_getenv_name;
 
 tdm_buffer_info buffer;
@@ -52,6 +54,20 @@ char *stub_getenv(const char *name)
        return NULL;
 }
 
+int stub_setenv(const char *name, const char *value, int replace)
+{
+       if (stub_setenv_real)
+               return setenv(name, value, replace);
+
+       if (SETENV_ERROR)
+               return 1;
+
+       stub_getenv_name = name;
+       stub_getenv_return_value = value;
+
+       return 0;
+}
+
 void stub_stdlib_init()
 {
        CALLOC_ERROR = 0;

diff --git a/ut/stubs/stub_stdlib.h b/ut/stubs/stub_stdlib.h
index 156af5c..e36e253 100644 (file)
--- a/ut/stubs/stub_stdlib.h
+++ b/ut/stubs/stub_stdlib.h
@@ -9,6 +9,7 @@ extern int CALLOC_ERROR;
 extern int CALLOC_RETURN_BUFFER;
 extern int FREE_CALLED;
 extern int GETENV_ERROR;
+extern int SETENV_ERROR;
 
 extern tdm_buffer_info buffer;
 extern char *stub_getenv_return_value;
@@ -20,6 +21,7 @@ void *stub_calloc(size_t nmemb, size_t size);
 void stub_free(void *ptr);
 
 char *stub_getenv(const char *name);
+int stub_setenv (const char *name, const char *value, int replace);
 
 void stub_stdlib_init();
 
@@ -27,6 +29,7 @@ void stub_stdlib_init();
 #define calloc stub_calloc
 #define free stub_free
 #define getenv stub_getenv
+#define setenv stub_setenv
 #endif
 
 #endif /* _STDLIB_STUBS_H */

diff --git a/ut/stubs/stub_unistd.h b/ut/stubs/stub_unistd.h
index d245445..e46afe9 100644 (file)
--- a/ut/stubs/stub_unistd.h
+++ b/ut/stubs/stub_unistd.h
@@ -40,6 +40,7 @@ int stub_poll(struct pollfd *fds, nfds_t nfds, int timeout);
 #define write(fd, buf, n) stub_write(fd, buf, n)
 #define read(fd, buf, nbytes) stub_read(fd, buf, nbytes)
 #define dup(fd) stub_dup(fd)
+#define dup2 stub_dup2
 #define poll(fds, nfds, timeout) stub_poll(fds, nfds, timeout)
 
 #endif // STUB_UNISTD_H

diff --git a/ut/stubs/tbm_stubs.cpp b/ut/stubs/tbm_stubs.cpp
index c19ec40..bc5d19b 100644 (file)
--- a/ut/stubs/tbm_stubs.cpp
+++ b/ut/stubs/tbm_stubs.cpp
@@ -173,11 +173,24 @@ int tbm_surface_internal_set_user_data(tbm_surface_h surface, unsigned long key,
 
 int tbm_surface_map(tbm_surface_h surface, int opt, tbm_surface_info_s *info)
 {
-       (void)surface;
        (void)opt;
-       (void)info;
-
-       return 0;
+       struct _tbm_surface *s = surface;
+
+       if (s->info.num_planes > 0)
+       {
+               info->format = s->info.format;
+               info->width = s->info.width;
+               info->height = s->info.height;
+               info->num_planes = s->info.num_planes;
+               info->planes[0].ptr = s->info.planes[0].ptr;
+               info->planes[1].ptr = s->info.planes[1].ptr;
+               info->planes[2].ptr = s->info.planes[2].ptr;
+               info->planes[0].stride = s->info.planes[0].stride;
+               info->planes[1].stride = s->info.planes[1].stride;
+               info->planes[2].stride = s->info.planes[2].stride;
+               return 0;
+       }
+       return 1;
 }
 
 int tbm_surface_unmap(tbm_surface_h surface)
@@ -204,9 +217,8 @@ int tbm_surface_internal_delete_user_data(tbm_surface_h surface,
 
 int tbm_surface_internal_get_num_bos(tbm_surface_h surface)
 {
-       (void)surface;
-
-       return 0;
+       struct _tbm_surface *s = surface;
+       return s->info.num_planes;
 }
 
 int tbm_surface_get_info(tbm_surface_h surface, tbm_surface_info_s *info)

diff --git a/ut/stubs/tbm_stubs.h b/ut/stubs/tbm_stubs.h
index f5124d8..4221941 100644 (file)
--- a/ut/stubs/tbm_stubs.h
+++ b/ut/stubs/tbm_stubs.h
@@ -11,6 +11,7 @@ extern int tbm_surface_queue_release_count;
 
 struct _tbm_surface {
        int temp;
+       tbm_surface_info_s info;
 };
 
 struct _tbm_surface_queue {

diff --git a/ut/stubs/tdm_event_loop_stubs.h b/ut/stubs/tdm_event_loop_stubs.h
index fa16029..4869cda 100644 (file)
--- a/ut/stubs/tdm_event_loop_stubs.h
+++ b/ut/stubs/tdm_event_loop_stubs.h
@@ -8,42 +8,42 @@ extern "C" {
 #include <tdm.h>
 #include "tdm_private.h"
 
-tdm_error
+static tdm_error
 ut_tdm_event_loop_init(tdm_private_display *private_display)
 {
        return TDM_ERROR_NONE;
 }
 
-void
+static void
 ut_tdm_event_loop_deinit(tdm_private_display *private_display)
 {
 }
 
-void
+static void
 ut_tdm_event_loop_create_backend_source(tdm_private_display *private_display)
 {
 }
 
-int
+static int
 ut_tdm_event_loop_get_fd(tdm_private_display *private_display)
 {
        return 1;
 }
 
-tdm_error
+static tdm_error
 ut_tdm_event_loop_dispatch(tdm_private_display *private_display)
 {
        return TDM_ERROR_NONE;
 }
 
 
-void
+static void
 ut_tdm_event_loop_flush(tdm_private_display *private_display)
 {
 }
 
 
-tdm_event_loop_source *
+static tdm_event_loop_source *
 ut_tdm_event_loop_add_fd_handler(tdm_display *dpy, int fd, tdm_event_loop_mask mask,
                                                          tdm_event_loop_fd_handler func, void *user_data,
                                                          tdm_error *error)
@@ -51,26 +51,26 @@ ut_tdm_event_loop_add_fd_handler(tdm_display *dpy, int fd, tdm_event_loop_mask m
        return (tdm_event_loop_source*)1;
 }
 
-tdm_error
+static tdm_error
 ut_tdm_event_loop_source_fd_update(tdm_event_loop_source *source, tdm_event_loop_mask mask)
 {
        return TDM_ERROR_NONE;
 }
 
-tdm_event_loop_source *
+static tdm_event_loop_source *
 ut_tdm_event_loop_add_timer_handler(tdm_display *dpy, tdm_event_loop_timer_handler func,
                                                                 void *user_data, tdm_error *error)
 {
        return (tdm_event_loop_source*)1;
 }
 
-tdm_error
+static tdm_error
 ut_tdm_event_loop_source_timer_update(tdm_event_loop_source *source, unsigned int ms_delay)
 {
        return TDM_ERROR_NONE;
 }
 
-void
+static void
 ut_tdm_event_loop_source_remove(tdm_event_loop_source *source)
 {
 }