From c3ff81d05224356b206ee3a3c740dfefe3116dce Mon Sep 17 00:00:00 2001 From: Hyoyoung Chang Date: Thu, 28 Oct 2010 16:50:17 +0900 Subject: [PATCH] [TC] adding scrolled entry --- TC/elm_ts/scrolled_entry/tslist | 57 +++++++++---- ...lm_scrolled_entry_autocapitalization_set_func.c | 94 +++++++++++++++++++++ ...c_UIFW_elm_scrolled_entry_autoperiod_set_func.c | 96 +++++++++++++++++++++ .../utc_UIFW_elm_scrolled_entry_bounce_set_func.c | 94 +++++++++++++++++++++ ...FW_elm_scrolled_entry_context_menu_clear_func.c | 95 +++++++++++++++++++++ ...scrolled_entry_context_menu_disabled_get_func.c | 97 +++++++++++++++++++++ ...scrolled_entry_context_menu_disabled_set_func.c | 94 +++++++++++++++++++++ ...elm_scrolled_entry_context_menu_item_add_func.c | 94 +++++++++++++++++++++ ...FW_elm_scrolled_entry_cursor_content_get_func.c | 98 ++++++++++++++++++++++ ..._elm_scrolled_entry_cursor_is_format_get_func.c | 96 +++++++++++++++++++++ ...olled_entry_cursor_is_visible_format_get_func.c | 96 +++++++++++++++++++++ ...lm_scrolled_entry_cursor_selection_begin_func.c | 95 +++++++++++++++++++++ ..._elm_scrolled_entry_cursor_selection_end_func.c | 95 +++++++++++++++++++++ ..._UIFW_elm_scrolled_entry_imf_context_get_func.c | 98 ++++++++++++++++++++++ ...m_scrolled_entry_input_panel_enabled_set_func.c | 95 +++++++++++++++++++++ ...lm_scrolled_entry_input_panel_layout_set_func.c | 94 +++++++++++++++++++++ ...IFW_elm_scrolled_entry_maximum_bytes_set_func.c | 94 +++++++++++++++++++++ ...d_entry_password_show_last_character_set_func.c | 95 +++++++++++++++++++++ ..._elm_scrolled_entry_scrollbar_policy_set_func.c | 95 +++++++++++++++++++++ ...c_UIFW_elm_scrolled_entry_selection_copy_func.c | 97 +++++++++++++++++++++ ...tc_UIFW_elm_scrolled_entry_selection_cut_func.c | 97 +++++++++++++++++++++ ..._UIFW_elm_scrolled_entry_selection_paste_func.c | 97 +++++++++++++++++++++ 22 files changed, 2045 insertions(+), 18 deletions(-) create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_autocapitalization_set_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_autoperiod_set_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_bounce_set_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_clear_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_disabled_get_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_disabled_set_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_item_add_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_content_get_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_is_format_get_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_is_visible_format_get_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_selection_begin_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_selection_end_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_imf_context_get_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_input_panel_enabled_set_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_input_panel_layout_set_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_maximum_bytes_set_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_password_show_last_character_set_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_scrollbar_policy_set_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_selection_copy_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_selection_cut_func.c create mode 100644 TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_selection_paste_func.c diff --git a/TC/elm_ts/scrolled_entry/tslist b/TC/elm_ts/scrolled_entry/tslist index 99d3daa..9c81127 100644 --- a/TC/elm_ts/scrolled_entry/tslist +++ b/TC/elm_ts/scrolled_entry/tslist @@ -1,23 +1,44 @@ /elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_add_func -/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_single_line_set_func -/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_single_line_get_func -/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_password_set_func -/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_password_get_func -/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_entry_set_func -/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_entry_get_func -/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_selection_get_func -/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_entry_insert_func -/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_line_wrap_set_func -/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_line_char_wrap_set_func -/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_editable_set_func -/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_editable_get_func -/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_select_none_func -/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_select_all_func -/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_next_func -/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_prev_func -/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_up_func -/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_down_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_autocapitalization_set_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_autoperiod_set_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_bounce_set_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_clear_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_disabled_get_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_disabled_set_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_item_add_func /elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_begin_set_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_content_get_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_down_func /elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_end_set_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_is_format_get_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_is_visible_format_get_func /elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_line_begin_set_func /elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_line_end_set_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_next_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_prev_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_selection_begin_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_selection_end_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_up_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_editable_get_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_editable_set_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_entry_get_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_entry_insert_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_entry_set_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_imf_context_get_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_input_panel_enabled_set_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_input_panel_layout_set_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_line_char_wrap_set_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_line_wrap_set_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_maximum_bytes_set_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_password_get_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_password_set_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_password_show_last_character_set_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_scrollbar_policy_set_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_select_all_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_select_none_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_selection_copy_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_selection_cut_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_selection_get_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_selection_paste_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_single_line_get_func +/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_single_line_set_func diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_autocapitalization_set_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_autocapitalization_set_func.c new file mode 100644 index 0000000..7913df1 --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_autocapitalization_set_func.c @@ -0,0 +1,94 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_autocapitalization_set_func_01(void); +static void utc_UIFW_elm_scrolled_entry_autocapitalization_set_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_autocapitalization_set_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_autocapitalization_set_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_autocapitalization_set() + */ +static void utc_UIFW_elm_scrolled_entry_autocapitalization_set_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + elm_scrolled_entry_autocapitalization_set(test_en, EINA_TRUE); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Setting a flag of autocapitalization at currently shown in scrolled entry is succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_autocapitalization_set() + */ +static void utc_UIFW_elm_scrolled_entry_autocapitalization_set_func_02(void) +{ + elm_scrolled_entry_autocapitalization_set(NULL, EINA_TRUE); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Setting a flag of autocapitalization at currently shown in scrolled entry is failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_autoperiod_set_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_autoperiod_set_func.c new file mode 100644 index 0000000..f9c661c --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_autoperiod_set_func.c @@ -0,0 +1,96 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_autoperiod_set_func_01(void); +static void utc_UIFW_elm_scrolled_entry_autoperiod_set_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_autoperiod_set_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_autoperiod_set_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_autoperiod_set() + */ +static void utc_UIFW_elm_scrolled_entry_autoperiod_set_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + elm_scrolled_entry_entry_set(test_en, "This is test entry"); + + elm_scrolled_entry_autoperiod_set(test_en, EINA_TRUE); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Setting a flag of autoperiod at currently shown in scrolled entry is succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_autoperiod_set() + */ +static void utc_UIFW_elm_scrolled_entry_autoperiod_set_func_02(void) +{ + elm_scrolled_entry_autoperiod_set(NULL, EINA_TRUE); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Setting a flag of autoperiod at currently shown in scrolled entry is failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_bounce_set_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_bounce_set_func.c new file mode 100644 index 0000000..72aa598 --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_bounce_set_func.c @@ -0,0 +1,94 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_bounce_set_func_01(void); +static void utc_UIFW_elm_scrolled_entry_bounce_set_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_bounce_set_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_bounce_set_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_bounce_set() + */ +static void utc_UIFW_elm_scrolled_entry_bounce_set_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + elm_scrolled_entry_bounce_set(test_en, EINA_TRUE, EINA_TRUE); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Setting a flag of bouncing at currently shown in scrolled entry is succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_bounce_set() + */ +static void utc_UIFW_elm_scrolled_entry_bounce_set_func_02(void) +{ + elm_scrolled_entry_bounce_set(NULL, EINA_TRUE, EINA_TRUE); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Setting a flag of bouncing at currently shown is scrolled entry is failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_clear_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_clear_func.c new file mode 100644 index 0000000..0f5589d --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_clear_func.c @@ -0,0 +1,95 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_context_menu_clear_func_01(void); +static void utc_UIFW_elm_scrolled_entry_context_menu_clear_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_context_menu_clear_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_context_menu_clear_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_context_menu_clear() + */ +static void utc_UIFW_elm_scrolled_entry_context_menu_clear_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + // void + elm_scrolled_entry_context_menu_clear(test_en); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Clearing context menu of currently shown in scrolled entry had succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_context_menu_clear() + */ +static void utc_UIFW_elm_scrolled_entry_context_menu_clear_func_02(void) +{ + elm_scrolled_entry_context_menu_clear(NULL); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Clearing context menu of currently shown is scrolled entry had failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_disabled_get_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_disabled_get_func.c new file mode 100644 index 0000000..33c5522 --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_disabled_get_func.c @@ -0,0 +1,97 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_context_menu_disabled_get_func_01(void); +static void utc_UIFW_elm_scrolled_entry_context_menu_disabled_get_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_context_menu_disabled_get_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_context_menu_disabled_get_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_context_menu_disabled_get() + */ +static void utc_UIFW_elm_scrolled_entry_context_menu_disabled_get_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + elm_scrolled_entry_context_menu_disabled_set(test_en, EINA_TRUE); + Eina_Bool r = elm_scrolled_entry_context_menu_disabled_get(test_en); + TET_CHECK_PASS(EINA_FALSE, r); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Getting a flag of context menu status at currently shown in scrolled entry is succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_context_menu_disabled_get() + */ +static void utc_UIFW_elm_scrolled_entry_context_menu_disabled_get_func_02(void) +{ + Eina_Bool r = elm_scrolled_entry_context_menu_disabled_get(NULL); + TET_CHECK_FAIL(EINA_FALSE, r); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Getting a flag of context menu status at currently shown is scrolled entry is failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_disabled_set_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_disabled_set_func.c new file mode 100644 index 0000000..a81f581 --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_disabled_set_func.c @@ -0,0 +1,94 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_context_menu_disabled_set_func_01(void); +static void utc_UIFW_elm_scrolled_entry_context_menu_disabled_set_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_context_menu_disabled_set_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_context_menu_disabled_set_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_context_menu_disabled_set() + */ +static void utc_UIFW_elm_scrolled_entry_context_menu_disabled_set_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + elm_scrolled_entry_context_menu_disabled_set(test_en, EINA_TRUE); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Disable the context menu at currently shown in scrolled entry is succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_context_menu_disabled_set() + */ +static void utc_UIFW_elm_scrolled_entry_context_menu_disabled_set_func_02(void) +{ + elm_scrolled_entry_context_menu_disabled_set(NULL, EINA_TRUE); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Disable the context menu at currently shown is scrolled entry is failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_item_add_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_item_add_func.c new file mode 100644 index 0000000..84cd087 --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_context_menu_item_add_func.c @@ -0,0 +1,94 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_context_menu_item_add_func_01(void); +static void utc_UIFW_elm_scrolled_entry_context_menu_item_add_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_context_menu_item_add_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_context_menu_item_add_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_context_menu_item_add() + */ +static void utc_UIFW_elm_scrolled_entry_context_menu_item_add_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + elm_scrolled_entry_context_menu_item_add(test_en, "Menu", NULL, ELM_ICON_NONE, NULL, NULL); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Adding a context menu item to currently shown in scrolled entry is succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_context_menu_item_add() + */ +static void utc_UIFW_elm_scrolled_entry_context_menu_item_add_func_02(void) +{ + elm_scrolled_entry_context_menu_item_add(NULL, "Menu", NULL, ELM_ICON_NONE, NULL, NULL); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Adding a context menu item to currently shown is scrolled entry is failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_content_get_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_content_get_func.c new file mode 100644 index 0000000..ca54d49 --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_content_get_func.c @@ -0,0 +1,98 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_cursor_content_get_func_01(void); +static void utc_UIFW_elm_scrolled_entry_cursor_content_get_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_cursor_content_get_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_cursor_content_get_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_cursor_content_get() + */ +static void utc_UIFW_elm_scrolled_entry_cursor_content_get_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + elm_scrolled_entry_entry_set(test_en, "This is test entry"); + + const char *s = elm_scrolled_entry_cursor_content_get(test_en); + TET_CHECK_PASS(NULL, s); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Getting the text in cursor position currently shown in scrolled entry had succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_cursor_content_get() + */ +static void utc_UIFW_elm_scrolled_entry_cursor_content_get_func_02(void) +{ + const char *s = elm_scrolled_entry_cursor_content_get(NULL); + TET_CHECK_FAIL(NULL, s); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Getting the text in cursor position currently shown is scrolled entry had failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_is_format_get_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_is_format_get_func.c new file mode 100644 index 0000000..88ee044 --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_is_format_get_func.c @@ -0,0 +1,96 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_cursor_is_format_get_func_01(void); +static void utc_UIFW_elm_scrolled_entry_cursor_is_format_get_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_cursor_is_format_get_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_cursor_is_format_get_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_cursor_is_format_get() + */ +static void utc_UIFW_elm_scrolled_entry_cursor_is_format_get_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + Eina_Bool r = elm_scrolled_entry_cursor_is_format_get(test_en); + TET_CHECK_PASS(EINA_FALSE, r); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Getting a flag of cursor is format at currently shown scrolled entry is succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_cursor_is_format_get() + */ +static void utc_UIFW_elm_scrolled_entry_cursor_is_format_get_func_02(void) +{ + Eina_Bool r = elm_scrolled_entry_cursor_is_format_get(NULL); + TET_CHECK_FAIL(EINA_FALSE, r); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Getting a flag of cursor is format at currently shown scrolled entry is failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_is_visible_format_get_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_is_visible_format_get_func.c new file mode 100644 index 0000000..d94be1f --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_is_visible_format_get_func.c @@ -0,0 +1,96 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_cursor_is_visible_format_get_func_01(void); +static void utc_UIFW_elm_scrolled_entry_cursor_is_visible_format_get_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_cursor_is_visible_format_get_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_cursor_is_visible_format_get_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_cursor_is_visible_format_get() + */ +static void utc_UIFW_elm_scrolled_entry_cursor_is_visible_format_get_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + Eina_Bool r = elm_scrolled_entry_cursor_is_visible_format_get(test_en); + TET_CHECK_PASS(EINA_FALSE, r); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Getting a flag of cursor is visible at currently shown in scrolled entry is succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_cursor_is_visible_format_get() + */ +static void utc_UIFW_elm_scrolled_entry_cursor_is_visible_format_get_func_02(void) +{ + Eina_Bool r = elm_scrolled_entry_cursor_is_visible_format_get(NULL); + TET_CHECK_FAIL(EINA_FALSE, r); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Getting a flag of cursor is visible at shown scrolled entry is failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_selection_begin_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_selection_begin_func.c new file mode 100644 index 0000000..4fe4a04 --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_selection_begin_func.c @@ -0,0 +1,95 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_cursor_selection_begin_func_01(void); +static void utc_UIFW_elm_scrolled_entry_cursor_selection_begin_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_cursor_selection_begin_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_cursor_selection_begin_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_cursor_selection_begin() + */ +static void utc_UIFW_elm_scrolled_entry_cursor_selection_begin_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + // void + elm_scrolled_entry_cursor_selection_begin(test_en); + tet_result(TET_PASS); + + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, set cursor selection at begin in shown scrolled entry is succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_cursor_selection_begin() + */ +static void utc_UIFW_elm_scrolled_entry_cursor_selection_begin_func_02(void) +{ + elm_scrolled_entry_cursor_selection_begin(NULL); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, set cursor selection at begin in shown scrolled entry is failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_selection_end_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_selection_end_func.c new file mode 100644 index 0000000..c933e6b --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_cursor_selection_end_func.c @@ -0,0 +1,95 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_cursor_selection_end_func_01(void); +static void utc_UIFW_elm_scrolled_entry_cursor_selection_end_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_cursor_selection_end_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_cursor_selection_end_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_cursor_selection_end() + */ +static void utc_UIFW_elm_scrolled_entry_cursor_selection_end_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + // void + elm_scrolled_entry_cursor_selection_end(test_en); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, set cursor selection at end in shown scrolled entry is succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_cursor_selection_end() + */ +static void utc_UIFW_elm_scrolled_entry_cursor_selection_end_func_02(void) +{ + elm_scrolled_entry_cursor_selection_end(NULL); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, set cursor selection at end in shown scrolled entry is failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_imf_context_get_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_imf_context_get_func.c new file mode 100644 index 0000000..90470c1 --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_imf_context_get_func.c @@ -0,0 +1,98 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_imf_context_get_func_01(void); +static void utc_UIFW_elm_scrolled_entry_imf_context_get_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_imf_context_get_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_imf_context_get_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_imf_context_get() + */ +static void utc_UIFW_elm_scrolled_entry_imf_context_get_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + Ecore_IMF_Context *s = NULL; + s = elm_scrolled_entry_imf_context_get(test_en); + TET_CHECK_PASS(NULL, s); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Getting the imf context currently shown in scrolled entry had succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_imf_context_get() + */ +static void utc_UIFW_elm_scrolled_entry_imf_context_get_func_02(void) +{ + Ecore_IMF_Context *s = NULL; + s = elm_scrolled_entry_imf_context_get(NULL); + TET_CHECK_FAIL(NULL, s); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Getting the imf context currently shown is scrolled entry had failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_input_panel_enabled_set_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_input_panel_enabled_set_func.c new file mode 100644 index 0000000..a255de3 --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_input_panel_enabled_set_func.c @@ -0,0 +1,95 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_input_panel_enabled_set_func_01(void); +static void utc_UIFW_elm_scrolled_entry_input_panel_enabled_set_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_input_panel_enabled_set_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_input_panel_enabled_set_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_input_panel_enabled_set() + */ +static void utc_UIFW_elm_scrolled_entry_input_panel_enabled_set_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + // void + elm_scrolled_entry_input_panel_enabled_set(test_en, EINA_TRUE); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Setting a flag of input panel enabled at currently shown in scrolled entry is succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_input_panel_enabled_set() + */ +static void utc_UIFW_elm_scrolled_entry_input_panel_enabled_set_func_02(void) +{ + elm_scrolled_entry_input_panel_enabled_set(NULL, EINA_TRUE); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Setting a flag of input panel enabled at currently shown is scrolled entry is failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_input_panel_layout_set_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_input_panel_layout_set_func.c new file mode 100644 index 0000000..6a538a9 --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_input_panel_layout_set_func.c @@ -0,0 +1,94 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_input_panel_layout_set_func_01(void); +static void utc_UIFW_elm_scrolled_entry_input_panel_layout_set_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_input_panel_layout_set_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_input_panel_layout_set_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_input_panel_layout_set() + */ +static void utc_UIFW_elm_scrolled_entry_input_panel_layout_set_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + elm_scrolled_entry_input_panel_layout_set(test_en, ELM_INPUT_PANEL_LAYOUT_NORMAL); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Setting the type of input panel layout at currently shown in scrolled entry is succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_input_panel_layout_set() + */ +static void utc_UIFW_elm_scrolled_entry_input_panel_layout_set_func_02(void) +{ + elm_scrolled_entry_input_panel_layout_set(NULL, ELM_INPUT_PANEL_LAYOUT_NORMAL); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Setting the type of input panel layout at currently shown is scrolled entry is failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_maximum_bytes_set_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_maximum_bytes_set_func.c new file mode 100644 index 0000000..9731c45 --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_maximum_bytes_set_func.c @@ -0,0 +1,94 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_maximum_bytes_set_func_01(void); +static void utc_UIFW_elm_scrolled_entry_maximum_bytes_set_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_maximum_bytes_set_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_maximum_bytes_set_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_maximum_bytes_set() + */ +static void utc_UIFW_elm_scrolled_entry_maximum_bytes_set_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + elm_scrolled_entry_maximum_bytes_set(test_en, 100); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Setting a maximum bytes limit at currently shown in scrolled entry is succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_maximum_bytes_set() + */ +static void utc_UIFW_elm_scrolled_entry_maximum_bytes_set_func_02(void) +{ + elm_scrolled_entry_maximum_bytes_set(NULL, 100); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Setting a maximum bytes limit at currently shown is scrolled entry is failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_password_show_last_character_set_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_password_show_last_character_set_func.c new file mode 100644 index 0000000..bcebeac --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_password_show_last_character_set_func.c @@ -0,0 +1,95 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_password_show_last_character_set_func_01(void); +static void utc_UIFW_elm_scrolled_entry_password_show_last_character_set_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_password_show_last_character_set_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_password_show_last_character_set_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_password_show_last_character_set() + */ +static void utc_UIFW_elm_scrolled_entry_password_show_last_character_set_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + //void + elm_scrolled_entry_password_show_last_character_set(test_en, EINA_TRUE); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Setting the flag of last character showing at currently shown in scrolled entry is succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_password_show_last_character_set() + */ +static void utc_UIFW_elm_scrolled_entry_password_show_last_character_set_func_02(void) +{ + elm_scrolled_entry_password_show_last_character_set(NULL, EINA_TRUE); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Setting the flag of last character showing at currently shown is scrolled entry is failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_scrollbar_policy_set_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_scrollbar_policy_set_func.c new file mode 100644 index 0000000..8894fcc --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_scrollbar_policy_set_func.c @@ -0,0 +1,95 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_scrollbar_policy_set_func_01(void); +static void utc_UIFW_elm_scrolled_entry_scrollbar_policy_set_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_scrollbar_policy_set_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_scrollbar_policy_set_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_scrollbar_policy_set() + */ +static void utc_UIFW_elm_scrolled_entry_scrollbar_policy_set_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + // void + elm_scrolled_entry_scrollbar_policy_set(test_en, EINA_TRUE, EINA_TRUE); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Setting the scrolling policy of currently shown in scrolled entry had succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_scrollbar_policy_set() + */ +static void utc_UIFW_elm_scrolled_entry_scrollbar_policy_set_func_02(void) +{ + elm_scrolled_entry_scrollbar_policy_set(NULL, EINA_TRUE, EINA_TRUE); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Setting the scrolling policy of currently shown is scrolled entry had failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_selection_copy_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_selection_copy_func.c new file mode 100644 index 0000000..e604c8a --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_selection_copy_func.c @@ -0,0 +1,97 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_selection_copy_func_01(void); +static void utc_UIFW_elm_scrolled_entry_selection_copy_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_selection_copy_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_selection_copy_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_selection_copy() + */ +static void utc_UIFW_elm_scrolled_entry_selection_copy_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + elm_scrolled_entry_entry_set(test_en, "This is test entry"); + + // void + elm_scrolled_entry_selection_copy(test_en); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Copying selection of the text currently shown in scrolled entry had succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_selection_copy() + */ +static void utc_UIFW_elm_scrolled_entry_selection_copy_func_02(void) +{ + elm_scrolled_entry_selection_copy(NULL); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Copying selection of the text currently shown is scrolled entry had failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_selection_cut_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_selection_cut_func.c new file mode 100644 index 0000000..6b61548 --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_selection_cut_func.c @@ -0,0 +1,97 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_selection_cut_func_01(void); +static void utc_UIFW_elm_scrolled_entry_selection_cut_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_selection_cut_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_selection_cut_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_selection_cut() + */ +static void utc_UIFW_elm_scrolled_entry_selection_cut_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + elm_scrolled_entry_entry_set(test_en, "This is test entry"); + + // void + elm_scrolled_entry_selection_cut(test_en); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Cutting selection of the text currently shown in scrolled entry had succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_selection_cut() + */ +static void utc_UIFW_elm_scrolled_entry_selection_cut_func_02(void) +{ + elm_scrolled_entry_selection_cut(NULL); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Cutting selection of the text currently shown is scrolled entry had failed."); + +} diff --git a/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_selection_paste_func.c b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_selection_paste_func.c new file mode 100644 index 0000000..9cb9c7d --- /dev/null +++ b/TC/elm_ts/scrolled_entry/utc_UIFW_elm_scrolled_entry_selection_paste_func.c @@ -0,0 +1,97 @@ +#include +#include + +// Definitions +// For checking the result of the positive test case. +#define TET_CHECK_PASS(x1, y...) \ +{ \ + const char *err = y; \ + if (err == (x1)) \ + { \ + tet_printf("[TET_CHECK_PASS]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + +// For checking the result of the negative test case. +#define TET_CHECK_FAIL(x1, y...) \ +{ \ + const char *err = y; \ + if (err != (x1)) \ + { \ + tet_printf("[TET_CHECK_FAIL]:: %s[%d] : Test has failed..", __FILE__,__LINE__); \ + tet_result(TET_FAIL); \ + return; \ + } \ +} + + +Evas_Object *main_win; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_UIFW_elm_scrolled_entry_selection_paste_func_01(void); +static void utc_UIFW_elm_scrolled_entry_selection_paste_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_UIFW_elm_scrolled_entry_selection_paste_func_01, POSITIVE_TC_IDX }, + { utc_UIFW_elm_scrolled_entry_selection_paste_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + tet_infoline("[[ TET_MSG ]]:: ============ Startup ============ "); + elm_init(0, NULL); + main_win = elm_win_add(NULL, "main", ELM_WIN_BASIC); + evas_object_show(main_win); +} + +static void cleanup(void) +{ + if ( NULL != main_win ) { + evas_object_del(main_win); + main_win = NULL; + } + elm_shutdown(); + tet_infoline("[[ TET_MSG ]]:: ============ Cleanup ============ "); +} + +/** + * @brief Positive test case of elm_scrolled_entry_selection_paste() + */ +static void utc_UIFW_elm_scrolled_entry_selection_paste_func_01(void) +{ + Evas_Object *test_en = elm_scrolled_entry_add(main_win); + + elm_scrolled_entry_entry_set(test_en, "This is test entry"); + + // void + elm_scrolled_entry_selection_paste(test_en); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_01, [TYPE]: Positive, [RESULT]:PASS, Pasting selection of the text currently shown in scrolled entry had succeed."); + +} + +/** + * @brief Negative test case of ug_init elm_scrolled_entry_selection_paste() + */ +static void utc_UIFW_elm_scrolled_entry_selection_paste_func_02(void) +{ + elm_scrolled_entry_selection_paste(NULL); + + tet_result(TET_PASS); + tet_infoline("[[ TET_MSG ]]::[ID]:TC_02, [TYPE]: Negative, [RESULT]:PASS, Pasting selection of the text currently shown is scrolled entry had failed."); + +} -- 2.7.4