#include "tbm_stubs.h"
#include "stub_pthread.h"
-#include "tdm_list_stubs.h"
#include "stub_stdlib.h"
#include "stub_backend.h"
+#include "stub_unistd.h"
+#include "stub_tdm_thread.h"
+#include "stub_tdm_buffer.h"
+#include "stub_tdm_helper.h"
#include "tdm_capture.c"
+//local stubs for callbeck functions
+static int stub_tdm_capture_done_handler_called;
+static void stub_tdm_capture_done_handler(tdm_capture *capture,
+ tbm_surface_h buffer, void *user_data)
+{
+ stub_tdm_capture_done_handler_called = 1;
+}
+
/* UNIT TESTS */
static void _init_test()
{
+ 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();
+ tdm_debug_dump = TDM_DUMP_FLAG_CAPTURE;
+ tdm_debug_module = TDM_DEBUG_BUFFER;
+ stub_tdm_capture_done_handler_called = 0;
}
/* tdm_capture_commit */
struct _tdm_private_display private_display;
tdm_private_output private_output;
tdm_error expected_error = TDM_ERROR_NONE;
+ tdm_pp_private_buffer b_1, b_2;
_init_test();
+ LIST_INITHEAD(&capture.pending_buffer_list);
+ LIST_INITHEAD(&capture.buffer_list);
+
+ LIST_ADD(&b_1.link, &capture.pending_buffer_list);
+ LIST_ADD(&b_2.link, &capture.pending_buffer_list);
+
capture.private_display = &private_display;
private_display.func_capture.capture_commit = capture_commit;
CALLOC_RETURN_BUFFER = 1;
error = tdm_capture_commit(&capture);
ASSERT_EQ(error, expected_error);
+ ASSERT_EQ(LIST_LENGTH(&capture.buffer_list), 2);
}
TEST(tdm_capture_commit, work_flow_success_3)
struct _tdm_private_capture capture;
struct _tdm_private_display private_display;
tdm_private_output private_output;
- tdm_error not_expected_error = TDM_ERROR_NONE;
+ tdm_pp_private_buffer b_1, b_2;
_init_test();
+ LIST_INITHEAD(&capture.pending_buffer_list);
+ LIST_INITHEAD(&capture.buffer_list);
+
+ LIST_ADD(&b_1.link, &capture.pending_buffer_list);
+ LIST_ADD(&b_2.link, &capture.pending_buffer_list);
+
capture.private_display = &private_display;
private_display.func_capture.capture_commit = capture_commit;
CAPTURE_COMMIT_ERROR = 1;
error = tdm_capture_commit(&capture);
- ASSERT_NE(error, not_expected_error);
+ ASSERT_NE(error, TDM_ERROR_NONE);
+ ASSERT_EQ(LIST_LENGTH(&capture.buffer_list), 0);
+ ASSERT_EQ(stub_tdm_buffer_remove_release_handler_internal_count, 2);
+ ASSERT_EQ(stub_tdm_buffer_unref_backend_count, 2);
}
TEST(tdm_capture_commit, work_flow_success_2)
_init_test();
+ LIST_INITHEAD(&capture.pending_buffer_list);
+
capture.private_display = &private_display;
private_display.func_capture.capture_commit = NULL;
capture.private_output = &private_output;
_init_test();
+ LIST_INITHEAD(&capture.pending_buffer_list);
+
capture.private_display = &private_display;
private_display.func_capture.capture_commit = NULL;
capture.private_output = &private_output;
ASSERT_EQ(error, expected_error);
}
-/* tdm_capture_attach */
+/* tdm_capture_set_info */
-TEST(tdm_capture_attach, null_ptr_fail_2)
+TEST(tdm_capture_set_info, error_capture_set_info_is_null)
{
- tdm_error error = TDM_ERROR_NONE;
+ tdm_info_capture info;
+ tdm_error error;
struct _tdm_private_capture capture;
- tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
+ struct _tdm_private_display private_display;
_init_test();
- error = tdm_capture_attach(&capture, NULL);
-
- ASSERT_EQ(error, expected_error);
-}
-
-TEST(tdm_capture_attach, null_ptr_fail_1)
-{
- tdm_error error = TDM_ERROR_NONE;
- struct _tbm_surface buffer;
- tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
-
- _init_test();
+ capture.private_display = &private_display;
+ private_display.func_capture.capture_set_info = NULL;
- error = tdm_capture_attach(NULL, &buffer);
+ error = tdm_capture_set_info(&capture, &info);
- ASSERT_EQ(error, expected_error);
+ ASSERT_EQ(error, TDM_ERROR_NOT_IMPLEMENTED);
}
-/* tdm_capture_set_info */
-
TEST(tdm_capture_set_info, work_flow_success_2)
{
tdm_info_capture info;
struct _tdm_private_capture capture;
struct _tdm_private_display private_display;
tdm_error expected_error = TDM_ERROR_NONE;
+ tdm_private_output private_output;
+ tdm_output_mode current_mode;
_init_test();
+ capture.private_output = &private_output;
+ private_output.current_mode = ¤t_mode;
+ current_mode.vrefresh = 24;
+ info.type = TDM_CAPTURE_TYPE_STREAM;
+ info.frequency = 0;
+
capture.private_display = &private_display;
private_display.func_capture.capture_set_info = capture_set_info;
error = tdm_capture_set_info(&capture, &info);
ASSERT_EQ(error, expected_error);
+ ASSERT_EQ(info.frequency, current_mode.vrefresh);
}
TEST(tdm_capture_set_info, work_flow_success_1)
_init_test();
+ LIST_INITHEAD(&private_layer.capture_list);
+ LIST_INITHEAD(&private_display.capture_list);
+
private_layer.private_output = &private_output;
private_output.private_display = &private_display;
private_display.func_layer.layer_create_capture = layer_create_capture;
_init_test();
+ LIST_INITHEAD(&private_layer.capture_list);
+ LIST_INITHEAD(&private_display.capture_list);
+
private_layer.private_output = &private_output;
private_output.private_display = &private_display;
private_display.func_layer.layer_create_capture = layer_create_capture;
_init_test();
+ LIST_INITHEAD(&private_layer.capture_list);
+ LIST_INITHEAD(&private_display.capture_list);
+
private_layer.private_output = &private_output;
private_output.private_display = &private_display;
private_display.func_layer.layer_create_capture = layer_create_capture;
_init_test();
+ LIST_INITHEAD(&private_layer.capture_list);
+ LIST_INITHEAD(&private_display.capture_list);
+
private_layer.private_output = &private_output;
private_output.private_display = &private_display;
private_display.capabilities = TDM_DISPLAY_CAPABILITY_PP;
tdm_private_capture *actual;
tdm_private_capture *not_expected = NULL;
tdm_error expected_error = TDM_ERROR_NONE;
+ tdm_private_capture private_capture;
_init_test();
+ LIST_INITHEAD(&private_output.capture_list);
+ LIST_INITHEAD(&private_display.capture_list);
+
private_output.private_display = &private_display;
private_display.func_output.output_create_capture = output_create_capture;
private_display.func_capture.capture_destroy = capture_destroy;
private_display.capabilities = TDM_DISPLAY_CAPABILITY_CAPTURE;
private_display.caps_capture.capabilities = TDM_CAPTURE_CAPABILITY_OUTPUT;
+ private_capture.stamp = stub_tdm_helper_get_time_ret_val;
+
+ LIST_ADD(&private_capture.display_link, &private_display.capture_list);
+
actual = tdm_capture_create_output_internal(&private_output, &error);
ASSERT_EQ(error, expected_error);
_init_test();
+ LIST_INITHEAD(&private_output.capture_list);
+ LIST_INITHEAD(&private_display.capture_list);
+
private_output.private_display = &private_display;
private_display.func_output.output_create_capture = output_create_capture;
private_display.func_capture.capture_destroy = capture_destroy;
_init_test();
+ LIST_INITHEAD(&private_output.capture_list);
+ LIST_INITHEAD(&private_display.capture_list);
+
private_output.private_display = &private_display;
private_display.func_output.output_create_capture = output_create_capture;
private_display.func_capture.capture_destroy = capture_destroy;
_init_test();
+ LIST_INITHEAD(&private_output.capture_list);
+ LIST_INITHEAD(&private_display.capture_list);
+
private_output.private_display = &private_display;
private_display.func_output.output_create_capture = output_create_capture;
private_display.capabilities = TDM_DISPLAY_CAPABILITY_CAPTURE;
_init_test();
+ LIST_INITHEAD(&private_output.capture_list);
+ LIST_INITHEAD(&private_display.capture_list);
+
private_output.private_display = &private_display;
private_display.capabilities = TDM_DISPLAY_CAPABILITY_PP;
actual = tdm_capture_create_output_internal(&private_output, &error);
ASSERT_EQ(error, expected_error);
ASSERT_TRUE(actual == expected);
}
+
+TEST(tdm_capture_create_output_internal, TDM_CAPTURE_CAPABILITY_OUTPUT_is_not_set)
+{
+ tdm_error error = TDM_ERROR_NONE;
+ struct _tdm_private_output private_output;
+ struct _tdm_private_display private_display;
+ tdm_private_capture *actual;
+ tdm_private_capture *expected = NULL;
+ tdm_error expected_error = TDM_ERROR_NO_CAPABILITY;
+
+ _init_test();
+
+ LIST_INITHEAD(&private_output.capture_list);
+ LIST_INITHEAD(&private_display.capture_list);
+
+ private_output.private_display = &private_display;
+ private_display.capabilities = TDM_DISPLAY_CAPABILITY_CAPTURE;
+ private_display.caps_capture.capabilities = TDM_CAPTURE_CAPABILITY_LAYER;
+
+ actual = tdm_capture_create_output_internal(&private_output, &error);
+
+ ASSERT_EQ(error, expected_error);
+ ASSERT_TRUE(actual == expected);
+}
+
+/* tdm_capture_cb_done() */
+
+TEST(tdm_capture_cb_done, success_not_in_display_thread)
+{
+ tdm_private_capture private_capture;
+ struct _tbm_surface buffer;
+ tdm_thread_cb_capture_done *capture_done;
+ tdm_private_display private_display;
+
+ _init_test();
+
+ private_capture.private_display = &private_display;
+ stub_syscall_return_value = 50;
+ private_capture.owner_tid = stub_syscall_return_value + 1;
+ private_capture.stamp = 10.15;
+
+ tdm_capture_cb_done(&private_capture, &buffer, &private_capture);
+
+ capture_done = (tdm_thread_cb_capture_done *)stub_tdm_thread_send_cb_buff;
+
+ ASSERT_EQ(capture_done->base.type, TDM_THREAD_CB_CAPTURE_DONE);
+ ASSERT_EQ(capture_done->base.length, sizeof * capture_done);
+ ASSERT_DOUBLE_EQ(capture_done->capture_stamp, private_capture.stamp);
+ ASSERT_TRUE(capture_done->buffer == &buffer);
+ ASSERT_TRUE(capture_done->user_data == &private_capture);
+}
+
+TEST(tdm_capture_cb_done, success_in_display_thread)
+{
+ tdm_private_capture private_capture;
+ struct _tbm_surface buffer;
+ tdm_thread_cb_capture_done *capture_done;
+ tdm_private_display private_display;
+ tdm_capture_private_buffer *capture_buffer_1;
+ tdm_capture_private_buffer *capture_buffer_2;
+
+ _init_test();
+
+ capture_buffer_1 = (tdm_capture_private_buffer *)
+ calloc(1, sizeof * capture_buffer_1);
+ capture_buffer_2 = (tdm_capture_private_buffer *)
+ calloc(1, sizeof * capture_buffer_2);
+
+ LIST_INITHEAD(&private_capture.buffer_list);
+ LIST_ADD(&capture_buffer_1->link, &private_capture.buffer_list);
+ LIST_ADD(&capture_buffer_2->link, &private_capture.buffer_list);
+
+ capture_buffer_1->buffer = &buffer;
+
+ private_capture.private_display = &private_display;
+ stub_syscall_return_value = 50;
+ stub_syscall_reset = 1;
+ private_capture.owner_tid = stub_syscall_return_value;
+ private_capture.done_func = stub_tdm_capture_done_handler;
+
+ tdm_capture_cb_done(&private_capture, &buffer, &private_capture);
+
+ ASSERT_EQ(FREE_CALLED, 1);
+ ASSERT_EQ(stub_tdm_capture_done_handler_called, 1);
+ ASSERT_EQ(stub_tdm_buffer_unref_backend_count, 1);
+ ASSERT_TRUE(!_tdm_capture_find_tbm_buffer(&private_capture.buffer_list, &buffer));
+}
+
+/* tdm_capture_find_stamp() */
+
+TEST(tdm_capture_find_stamp, success_capture_list_is_empty)
+{
+ tdm_private_capture *capture_ret;
+ tdm_private_display private_display;
+
+ _init_test();
+
+ LIST_INITHEAD(&private_display.capture_list);
+
+ capture_ret = tdm_capture_find_stamp(&private_display, 0.5);
+
+ ASSERT_EQ(capture_ret, NULL);
+}
+
+TEST(tdm_capture_find_stamp, success)
+{
+ tdm_private_capture *capture_ret;
+ tdm_private_display private_display;
+ double stamp = 54.54;
+ tdm_private_capture capture;
+
+ _init_test();
+
+ capture.stamp = stamp;
+
+ LIST_INITHEAD(&private_display.capture_list);
+ LIST_ADD(&capture.display_link, &private_display.capture_list);
+
+ capture_ret = tdm_capture_find_stamp(&private_display, stamp);
+
+ ASSERT_EQ(capture_ret, &capture);
+}
+
+/* tdm_capture_destroy_internal() */
+
+TEST(tdm_capture_destroy_internal, success)
+{
+ tdm_private_capture *capture;
+ tdm_private_display private_display;
+ struct list_head list;
+ struct list_head dsp_list;
+ tdm_buffer_info *b1, *b2;
+
+ _init_test();
+
+ b1 = (tdm_buffer_info *)calloc(1, sizeof * b1);
+ b2 = (tdm_buffer_info *)calloc(1, sizeof * b2);
+
+ capture = (tdm_private_capture *)calloc(1, sizeof * capture);
+ capture->private_display = &private_display;
+
+ private_display.func_capture.capture_destroy = capture_destroy;
+
+ LIST_INITHEAD(&list);
+ LIST_INITHEAD(&dsp_list);
+ LIST_INITHEAD(&capture->pending_buffer_list);
+ LIST_INITHEAD(&capture->buffer_list);
+
+ LIST_ADD(&capture->link, &list);
+ LIST_ADD(&capture->display_link, &dsp_list);
+ LIST_ADD(&b1->link, &capture->pending_buffer_list);
+ LIST_ADD(&b2->link, &capture->buffer_list);
+
+ tdm_capture_destroy_internal(capture);
+
+ ASSERT_TRUE(LIST_IS_EMPTY(&list));
+ ASSERT_TRUE(LIST_IS_EMPTY(&dsp_list));
+ ASSERT_EQ(stub_tdm_buffer_unref_backend_count, 2);
+ ASSERT_EQ(FREE_CALLED, 1);
+ ASSERT_EQ(capture_destroy_is_called, 1);
+}
+
+/* tdm_capture_destroy() */
+
+TEST(tdm_capture_destroy, success)
+{
+ tdm_private_capture *capture;
+ tdm_private_display private_display;
+ struct list_head list;
+ struct list_head dsp_list;
+ tdm_buffer_info *b1, *b2;
+
+ _init_test();
+
+ b1 = (tdm_buffer_info *)calloc(1, sizeof * b1);
+ b2 = (tdm_buffer_info *)calloc(1, sizeof * b2);
+
+ capture = (tdm_private_capture *)calloc(1, sizeof * capture);
+ capture->private_display = &private_display;
+
+ private_display.func_capture.capture_destroy = capture_destroy;
+
+ LIST_INITHEAD(&list);
+ LIST_INITHEAD(&dsp_list);
+ LIST_INITHEAD(&capture->pending_buffer_list);
+ LIST_INITHEAD(&capture->buffer_list);
+
+ LIST_ADD(&capture->link, &list);
+ LIST_ADD(&capture->display_link, &dsp_list);
+ LIST_ADD(&b1->link, &capture->pending_buffer_list);
+ LIST_ADD(&b2->link, &capture->buffer_list);
+
+ tdm_capture_destroy(capture);
+
+ ASSERT_TRUE(LIST_IS_EMPTY(&list));
+ ASSERT_TRUE(LIST_IS_EMPTY(&dsp_list));
+ ASSERT_EQ(stub_tdm_buffer_unref_backend_count, 2);
+ ASSERT_EQ(FREE_CALLED, 1);
+ ASSERT_EQ(capture_destroy_is_called, 1);
+}
+
+/* tdm_capture_set_done_handler() */
+
+TEST(tdm_capture_set_done_handler, error_capture_is_null)
+{
+ tdm_error error;
+
+ error = tdm_capture_set_done_handler(NULL, stub_tdm_capture_done_handler, NULL);
+
+ ASSERT_EQ(error, TDM_ERROR_INVALID_PARAMETER);
+}
+
+TEST(tdm_capture_set_done_handler, error_func_is_null)
+{
+ tdm_error error;
+ tdm_private_capture capture;
+
+ error = tdm_capture_set_done_handler(&capture, NULL, NULL);
+
+ ASSERT_EQ(error, TDM_ERROR_INVALID_PARAMETER);
+}
+
+TEST(tdm_capture_set_done_handler, success)
+{
+ tdm_error error;
+ tdm_private_capture capture;
+ int user_data;
+
+ error = tdm_capture_set_done_handler(&capture, stub_tdm_capture_done_handler, &user_data);
+
+ ASSERT_EQ(error, TDM_ERROR_NONE);
+ ASSERT_TRUE(capture.done_func == stub_tdm_capture_done_handler);
+ ASSERT_TRUE(capture.done_user_data == &user_data);
+}
+
+/* tdm_capture_attach() */
+
+TEST(tdm_capture_attach, error_buffer_is_null)
+{
+ tdm_error error = TDM_ERROR_NONE;
+ struct _tdm_private_capture capture;
+ tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
+
+ _init_test();
+
+ error = tdm_capture_attach(&capture, NULL);
+
+ ASSERT_EQ(error, expected_error);
+}
+
+TEST(tdm_capture_attach, error_capture_is_null)
+{
+ tdm_error error = TDM_ERROR_NONE;
+ struct _tbm_surface buffer;
+
+ _init_test();
+
+ error = tdm_capture_attach(NULL, &buffer);
+
+ ASSERT_EQ(error, TDM_ERROR_INVALID_PARAMETER);
+}
+
+TEST(tdm_capture_attach, error_func_capture_attach_is_null)
+{
+ tdm_error error = TDM_ERROR_NONE;
+ struct _tdm_private_capture capture;
+ struct _tbm_surface buffer;
+ tdm_private_display dsp;
+
+ _init_test();
+
+ capture.private_display = &dsp;
+ dsp.func_capture.capture_attach = NULL;
+
+ error = tdm_capture_attach(&capture, &buffer);
+
+ ASSERT_EQ(error, TDM_ERROR_NOT_IMPLEMENTED);
+}
+
+TEST(tdm_capture_attach, error_length_of_pending_buffer_list_ge_max_attach_count)
+{
+ tdm_error error = TDM_ERROR_NONE;
+ struct _tdm_private_capture capture;
+ struct _tbm_surface buffer;
+ tdm_private_display dsp;
+ tdm_backend_module module;
+ tdm_capture_private_buffer b1, b2;
+
+ _init_test();
+
+ capture.private_display = &dsp;
+ dsp.func_capture.capture_attach = capture_attach;
+
+ dsp.module_data = &module;
+ module.abi_version = 0x000100002;
+
+ LIST_INITHEAD(&capture.pending_buffer_list);
+ LIST_INITHEAD(&capture.buffer_list);
+ LIST_ADD(&b1.link, &capture.pending_buffer_list);
+ LIST_ADD(&b2.link, &capture.pending_buffer_list);
+
+ dsp.caps_capture.max_attach_count = 1;
+
+ error = tdm_capture_attach(&capture, &buffer);
+
+ ASSERT_EQ(error, TDM_ERROR_BAD_REQUEST);
+}
+
+TEST(tdm_capture_attach, error_calloc)
+{
+ tdm_error error = TDM_ERROR_NONE;
+ struct _tdm_private_capture capture;
+ struct _tbm_surface buffer;
+ tdm_private_display dsp;
+ tdm_backend_module module;
+
+ _init_test();
+
+ capture.private_display = &dsp;
+ dsp.func_capture.capture_attach = capture_attach;
+
+ dsp.module_data = &module;
+ module.abi_version = 0x000100002;
+
+ LIST_INITHEAD(&capture.pending_buffer_list);
+ LIST_INITHEAD(&capture.buffer_list);
+
+ dsp.caps_capture.max_attach_count = 3;
+
+ CALLOC_ERROR = 1;
+
+ error = tdm_capture_attach(&capture, &buffer);
+
+ ASSERT_EQ(error, TDM_ERROR_OUT_OF_MEMORY);
+}
+
+TEST(tdm_capture_attach, error_capture_attach)
+{
+ tdm_error error = TDM_ERROR_NONE;
+ struct _tdm_private_capture capture;
+ struct _tbm_surface buffer;
+ tdm_private_display dsp;
+ tdm_backend_module module;
+
+ _init_test();
+
+ capture.private_display = &dsp;
+ dsp.func_capture.capture_attach = capture_attach;
+
+ dsp.module_data = &module;
+ module.abi_version = 0x000100002;
+
+ LIST_INITHEAD(&capture.pending_buffer_list);
+ LIST_INITHEAD(&capture.buffer_list);
+
+ dsp.caps_capture.max_attach_count = 3;
+
+ CAPTURE_ATTACH_ERROR = 1;
+
+ error = tdm_capture_attach(&capture, &buffer);
+
+ ASSERT_NE(error, TDM_ERROR_NONE);
+}
+
+TEST(tdm_capture_attach, success)
+{
+ tdm_error error = TDM_ERROR_NONE;
+ struct _tdm_private_capture capture;
+ struct _tbm_surface buffer;
+ tdm_private_display dsp;
+ tdm_backend_module module;
+ tdm_capture_private_buffer *capture_buffer;
+
+ _init_test();
+
+ capture.private_display = &dsp;
+ dsp.func_capture.capture_attach = capture_attach;
+
+ dsp.module_data = &module;
+ module.abi_version = 0x000100002;
+
+ LIST_INITHEAD(&capture.pending_buffer_list);
+ LIST_INITHEAD(&capture.buffer_list);
+
+ dsp.caps_capture.max_attach_count = 3;
+
+ error = tdm_capture_attach(&capture, &buffer);
+
+ ASSERT_EQ(error, TDM_ERROR_NONE);
+ ASSERT_TRUE(!LIST_IS_EMPTY(&capture.pending_buffer_list));
+ free(container_of(capture.pending_buffer_list.next, capture_buffer, link));
+}