ut: improve code coverage of tdm_pp.c

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

diff --git a/ut/src/ut_tdm_pp.cpp b/ut/src/ut_tdm_pp.cpp
index b03e35e..3f4d93a 100644 (file)
--- a/ut/src/ut_tdm_pp.cpp
+++ b/ut/src/ut_tdm_pp.cpp
@@ -31,17 +31,106 @@
 #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;
+
+       stub_pp_destroy_is_called = 1;
+}
+
+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;
+
+       if (stub_pp_set_done_handler_error)
+               return TDM_ERROR_OPERATION_FAILED;
+
+       stub_pp_set_done_handler_is_called = 1;
+       return TDM_ERROR_NONE;
+}
+
+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;
+
+       if (stub_display_create_pp_error) {
+               if (error)
+                       *error = TDM_ERROR_OPERATION_FAILED;
+               return NULL;
+       }
+       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;
+}
+
+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;
+
+       stub_tdm_pp_done_handler_is_called = 1;
+}
+
 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;
 }
 
 /* UNIT TESTS */
@@ -51,9 +140,9 @@ static void _init_test()
 TEST(tdm_pp_commit, work_flow_success_3)
 {
        tdm_error error = TDM_ERROR_OPERATION_FAILED;
-       tdm_error expected_error = TDM_ERROR_NONE;
        tdm_private_pp pp;
        tdm_private_display private_display;
+       tdm_pp_private_buffer b_1, b_2;
 
        _init_test();
 
@@ -61,10 +150,16 @@ TEST(tdm_pp_commit, work_flow_success_3)
        private_display.func_pp.pp_commit = pp_commit;
 
        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_EQ(error, expected_error);
+       ASSERT_EQ(error, TDM_ERROR_NONE);
+       ASSERT_EQ(LIST_LENGTH(&pp.buffer_list), 2);
 }
 
 TEST(tdm_pp_commit, work_flow_success_2)
@@ -73,6 +168,7 @@ TEST(tdm_pp_commit, work_flow_success_2)
        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();
 
@@ -81,10 +177,17 @@ TEST(tdm_pp_commit, work_flow_success_2)
        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)
@@ -118,6 +221,146 @@ TEST(tdm_pp_commit, null_ptr_fail_1)
 
 /* tdm_pp_attach */
 
+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;
+
+       _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);
+
+       stub_pp_attach_error = 1;
+
+       error = tdm_pp_attach(&private_pp, &src, &dst);
+
+       ASSERT_NE(TDM_ERROR_NONE, error);
+}
+
+TEST(tdm_pp_attach, error_calloc_error)
+{
+       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);
+
+       CALLOC_ERROR = 1;
+
+       error = tdm_pp_attach(&private_pp, &src, &dst);
+
+       ASSERT_EQ(TDM_ERROR_OUT_OF_MEMORY, error);
+}
+
+TEST(tdm_pp_attach, error_bad_request)
+{
+       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);
+}
+
+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;
+
+       error = tdm_pp_attach(&private_pp, &src, &dst);
+
+       ASSERT_EQ(TDM_ERROR_NOT_IMPLEMENTED, error);
+}
+
+TEST(tdm_pp_attach, work_flow_success_1)
+{
+       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);
+
+       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);
+}
+
 TEST(tdm_pp_attach, null_ptr_fail_3)
 {
        tdm_error error = TDM_ERROR_NONE;
@@ -251,3 +494,286 @@ TEST(tdm_pp_set_info, null_ptr_fail_1)
 
        ASSERT_EQ(error, expected_error);
 }
+
+TEST(tdm_pp_set_done_handler, work_flow_success_1)
+{
+       tdm_error error;
+       tdm_private_pp pp;
+       tdm_private_display private_display;
+       int user_data = 0;
+
+       _init_test();
+
+       pp.private_display = &private_display;
+       private_display.func_pp.pp_set_info = NULL;
+
+       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);
+
+       error = tdm_pp_set_done_handler(&pp, stub_tdm_pp_done_handler, NULL);
+       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)
+{
+       tdm_error error;
+       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_done_handler(&pp, NULL, NULL);
+       ASSERT_NE(TDM_ERROR_NONE, error);
+
+       error = tdm_pp_set_done_handler(NULL, stub_tdm_pp_done_handler, NULL);
+       ASSERT_NE(TDM_ERROR_NONE, error);
+}
+
+TEST(tdm_pp_destroy, work_flow_success_1)
+{
+       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);
+
+       LIST_INITHEAD(&private_pp->buffer_list);
+       LIST_ADDTAIL(&pp_buffer2->link, &private_pp->buffer_list);
+
+       tdm_pp_destroy(private_pp);
+
+       ASSERT_EQ(4, stub_tdm_buffer_unref_backend_count);
+       ASSERT_EQ(3, stub_free_call_count);
+       ASSERT_TRUE(stub_pp_destroy_is_called);
+}
+
+TEST(tdm_pp_destroy, work_flow_error_1___NULL)
+{
+       tdm_pp_destroy(NULL);
+}
+
+/* tdm_pp_create_internal() */
+
+TEST(tdm_pp_create_internal, work_flow_success_1)
+{
+       tdm_error error;
+       tdm_private_display private_display;
+       tdm_private_pp *private_pp_ret;
+       tdm_private_pp private_pp;
+
+       _init_test();
+
+       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);
+
+       private_pp.stamp = stub_tdm_helper_get_time_ret_val;
+
+       LIST_ADD(&private_pp.link, &private_display.pp_list);
+
+       private_pp_ret = tdm_pp_create_internal(&private_display, &error);
+
+       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_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);
+
+
+       private_display.capabilities = (tdm_display_capability)0;
+
+       private_pp = tdm_pp_create_internal(&private_display, &error);
+       ASSERT_NE(TDM_ERROR_NONE, error);
+       ASSERT_TRUE(private_pp == NULL);
+}
+
+TEST(tdm_pp_create_internal, work_flow_error_1___calloc_error)
+{
+       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);
+
+       CALLOC_ERROR = 1;
+
+       private_pp = tdm_pp_create_internal(&private_display, &error);
+       ASSERT_NE(TDM_ERROR_NONE, error);
+       ASSERT_TRUE(private_pp == NULL);
+}
+
+TEST(tdm_pp_create_internal, work_flow_error_1___create_pp_error)
+{
+       tdm_error error;
+       tdm_private_display private_display;
+       tdm_private_pp *private_pp;
+
+       _init_test();
+
+       stub_display_create_pp_error = 1;
+       private_display.func_display.display_create_pp = stub_display_create_pp;
+       private_display.capabilities = TDM_DISPLAY_CAPABILITY_PP;
+
+       private_pp = tdm_pp_create_internal(&private_display, &error);
+       ASSERT_NE(TDM_ERROR_NONE, error);
+       ASSERT_TRUE(private_pp == NULL);
+}
+
+TEST(tdm_pp_create_internal, work_flow_error_1___set_done_handler_error)
+{
+       tdm_error error;
+       tdm_private_display private_display;
+       tdm_private_pp *private_pp;
+
+       _init_test();
+
+       stub_pp_set_done_handler_error = 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);
+
+       private_pp = tdm_pp_create_internal(&private_display, &error);
+       ASSERT_NE(TDM_ERROR_NONE, error);
+       ASSERT_TRUE(private_pp == NULL);
+}
+
+/* tdm_pp_cb_done() */
+
+TEST(tdm_pp_cb_done, success_not_in_display_thread)
+{
+       tdm_private_pp private_pp;
+       struct _tbm_surface src, dst;
+       tdm_thread_cb_pp_done *pp_done;
+
+       _init_test();
+
+       stub_syscall_return_value = 100;
+       private_pp.owner_tid = stub_syscall_return_value + 1;
+       private_pp.stamp = 200.05;
+
+       tdm_pp_cb_done(&private_pp, &src, &dst, &private_pp);
+
+       pp_done = (tdm_thread_cb_pp_done *)stub_tdm_thread_send_cb_buff;
+
+       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);
+}
+
+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);
+
+       private_pp_ret = tdm_pp_find_stamp(&private_display, 0.5);
+
+       ASSERT_TRUE(private_pp_ret == NULL);
+}
+
+TEST(tdm_pp_find_stamp, success_pp_find_stamp)
+{
+       tdm_private_pp *private_pp_ret;
+       tdm_private_display private_display;
+       tdm_private_pp private_pp;
+       double stamp = 12.25;
+
+       _init_test();
+
+       LIST_INITHEAD(&private_display.pp_list);
+       LIST_ADD(&private_pp.link, &private_display.pp_list);
+
+       private_pp.stamp = stamp;
+
+       private_pp_ret = tdm_pp_find_stamp(&private_display, stamp);
+
+       ASSERT_TRUE(private_pp_ret == &private_pp);
+}

diff --git a/ut/stubs/stub_stdlib.cpp b/ut/stubs/stub_stdlib.cpp
index 1369cd0..55405a7 100644 (file)
--- a/ut/stubs/stub_stdlib.cpp
+++ b/ut/stubs/stub_stdlib.cpp
@@ -12,6 +12,7 @@ char *stub_getenv_return_value;
 int stub_getenv_return_real_value;
 int stub_setenv_real;
 char *stub_getenv_name;
+int stub_free_call_count;
 
 tdm_buffer_info buffer;
 
@@ -31,6 +32,7 @@ void *stub_calloc(size_t nmemb, size_t size)
 void stub_free(void *ptr)
 {
        FREE_CALLED = 1;
+       stub_free_call_count++;
        free(ptr);
 }
 
@@ -77,4 +79,5 @@ void stub_stdlib_init()
        stub_getenv_return_value = NULL;
        stub_getenv_name = NULL;
        stub_getenv_return_real_value = 0;
+       stub_free_call_count = 0;
 }

diff --git a/ut/stubs/stub_stdlib.h b/ut/stubs/stub_stdlib.h
index e36e253..e923976 100644 (file)
--- a/ut/stubs/stub_stdlib.h
+++ b/ut/stubs/stub_stdlib.h
@@ -15,6 +15,7 @@ extern tdm_buffer_info buffer;
 extern char *stub_getenv_return_value;
 extern char *stub_getenv_name;
 extern int stub_getenv_return_real_value;
+extern int stub_free_call_count;
 
 void *stub_calloc(size_t nmemb, size_t size);
 

diff --git a/ut/stubs/stub_tdm_buffer.h b/ut/stubs/stub_tdm_buffer.h
index 43dee2a..81d76ef 100644 (file)
--- a/ut/stubs/stub_tdm_buffer.h
+++ b/ut/stubs/stub_tdm_buffer.h
@@ -2,10 +2,12 @@
 #define STUB_TDM_BUFFER_H
 
 static int stub_tdm_buffer_unref_backend_count;
+static int stub_tdm_buffer_remove_release_handler_internal_count;
 
 static void stub_tdm_buffer_init()
 {
        stub_tdm_buffer_unref_backend_count = 0;
+       stub_tdm_buffer_remove_release_handler_internal_count = 0;
 }
 
 static tbm_surface_h stub_tdm_buffer_ref_backend(tbm_surface_h buffer)
@@ -22,7 +24,14 @@ static void stub_tdm_buffer_unref_backend(tbm_surface_h buffer)
        stub_tdm_buffer_unref_backend_count++;
 }
 
+static void
+stub_tdm_buffer_remove_release_handler_internal(tbm_surface_h buffer)
+{
+       stub_tdm_buffer_remove_release_handler_internal_count++;
+}
+
 #define tdm_buffer_ref_backend stub_tdm_buffer_ref_backend
 #define tdm_buffer_unref_backend stub_tdm_buffer_unref_backend
+#define tdm_buffer_remove_release_handler_internal stub_tdm_buffer_remove_release_handler_internal
 
 #endif // STUB_TDM_BUFFER_H