From: Pawel Szewczyk Date: Wed, 11 Feb 2015 09:13:01 +0000 (+0100) Subject: libusbgx: tests: Add getting functions tests X-Git-Tag: libusbgx-v0.1.0~118 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=30dfcc89fa1a6152eadeab33b1ce43c10ab1620d;p=platform%2Fupstream%2Flibusbg.git libusbgx: tests: Add getting functions tests Change-Id: I89296562177061559de84aa5332d8dc9347d2e13 Signed-off-by: Pawel Szewczyk [Update description] Signed-off-by: Krzysztof Opasiak --- diff --git a/tests/test.c b/tests/test.c index 87cbe67..a695012 100644 --- a/tests/test.c +++ b/tests/test.c @@ -58,34 +58,49 @@ static struct test_function simple_funcs[] = { static struct test_function all_funcs[] = { { .type = F_SERIAL, - .instance = "0" + .instance = "serial_instance0" }, { .type = F_ACM, - .instance = "0" + .instance = "acm_instance0" }, { .type = F_OBEX, - .instance = "0" + .instance = "obex_instance0" }, { .type = F_ECM, - .instance = "0" + .instance = "ecm_instance0" }, { .type = F_SUBSET, - .instance = "0" + .instance = "subset_instance0" }, { .type = F_NCM, - .instance = "0" + .instance = "ncm_instance0" }, { .type = F_EEM, - .instance = "0" + .instance = "eem_instance0" }, { .type = F_RNDIS, - .instance = "0" + .instance = "rndis_instance0" }, { .type = F_PHONET, - .instance = "0" + .instance = "phonet_instance0" }, { .type = F_FFS, + .instance = "ffs_instance0" + }, + + TEST_FUNCTION_LIST_END +}; + +static struct test_function same_type_funcs[] = { + { + .type = F_SERIAL, .instance = "0" + }, { + .type = F_SERIAL, + .instance = "1" + }, { + .type = F_SERIAL, + .instance = "2" }, TEST_FUNCTION_LIST_END @@ -178,6 +193,57 @@ static struct test_state all_funcs_state = { }; /** + * @brief Prepare test_state with one gadget containing given function list + * @details For testing only functions. We put them in a gadget as simply + * as possible. + * @param[in] func Pointer to list of functions + * @return Pointer to test state with given functions + */ +static struct test_state *put_func_in_state(struct test_function *func) +{ + struct test_state *st; + struct test_gadget *g; + struct test_config *c; + char **udcs; + + st = malloc(sizeof(*st)); + if (st == NULL) + fail(); + free_later(st); + + /* Do not need config */ + c = calloc(1, sizeof(*c)); + if (c == NULL) + fail(); + free_later(c); + + g = calloc(2, sizeof(*g)); + if (g == NULL) + fail(); + free_later(g); + + udcs = calloc(2, sizeof(*udcs)); + if (udcs == NULL) + fail(); + free_later(udcs); + + g[0].name = "g1"; + g[0].udc = "UDC1"; + g[0].configs = c; + g[0].functions = func; + + udcs[0] = "UDC1"; + + st->configfs_path = "config"; + st->gadgets = g; + st->udcs = udcs; + + prepare_state(st); + + return st; +} + +/** * @brief Setup simple state with some gadgets, configs and functions */ static void setup_simple_state(void **state) @@ -196,6 +262,14 @@ static void setup_all_funcs_state(void **state) } /** + * @brief Setup state with few functions of the same type + */ +static void setup_same_type_funcs_state(void **state) +{ + *state = put_func_in_state(same_type_funcs); +} + +/** * @brief Tests usbg_get_gadget function with given state * @details Check if gadgets are returned correctly */ @@ -425,6 +499,193 @@ static void test_init(void **state) } /** + * @brief Test getting function by name + * @param[in] state Pointer to pointer to correctly initialized test_state structure + */ +static void test_get_function(void **state) +{ + for_each_test_function(state, assert_func_equal); +} + +/** + * @brief Tests usbg_get_function with some non-existing functions + * @details Check if get function will return NULL, when invalid + * functions names and types are passed as arguments and will not cause crash. + * @param[in] state Pointer to pointer to correctly initialized test_state structure + */ +static void test_get_function_fail(void **state) +{ + usbg_state *s = NULL; + usbg_gadget *g = NULL; + usbg_function *f = NULL; + struct test_state *st; + + st = (struct test_state *)(*state); + *state = NULL; + + init_with_state(st, &s); + *state = s; + + g = usbg_get_first_gadget(s); + assert_non_null(g); + + f = usbg_get_function(g, F_ACM, "non-existing-instance"); + assert_null(f); + + f = usbg_get_function(g, 9001, "0"); + assert_null(f); +} + + +/** + * @brief Tests function type translation to string + * @param[in] state Pointer to pointer to correctly initialized test_state structure + * @details Check if get_function_type_str returns proper strings for all types. + */ +static void test_get_function_type_str(void **state) +{ + struct { + usbg_function_type type; + const char *str; + } types[] = { + {F_SERIAL, "gser"}, + {F_ACM, "acm"}, + {F_OBEX, "obex"}, + {F_ECM, "ecm"}, + {F_SUBSET, "geth"}, + {F_NCM, "ncm"}, + {F_EEM, "eem"}, + {F_RNDIS, "rndis"}, + {F_PHONET, "phonet"}, + {F_FFS, "ffs"} + }; + + const char *str; + int i; + + for (i = 0; i < ARRAY_SIZE(types); i++) { + str = usbg_get_function_type_str(types[i].type); + assert_non_null(str); + assert_string_equal(str, types[i].str); + } +} + +/** + * @brief Tests function type translation to string with unknown funcs + * @param[in] state Not used parameter + * @details Check if get_function_type_str returns NULL, when given + * function type is unknown. + */ +static void test_get_function_type_str_fail(void **state) +{ + const char *str; + + str = usbg_get_function_type_str(-1); + assert_null(str); +} + +/** + * @brief Get instance of given function and check it + * @param[in] f Usbg function + * @param[in] tf Test function which should match f + */ +static void try_get_function_instance(usbg_function *f, struct test_function *tf) +{ + const char *str; + + str = usbg_get_function_instance(f); + assert_string_equal(str, tf->instance); +} + +/** + * @brief Tests getting function instance from usbg_function structure + * @param[in] state Pointer to pointer to correctly initialized test_state structure + * @details Check if returned instance name is correct. + */ +static void test_get_function_instance(void **state) +{ + for_each_test_function(state, try_get_function_instance); +} + +/** + * @brief Cpy instance of given usbg function and check it + * @param[in] f Usbg function + * @param[in] tf Test function which should match f + */ +static void try_cpy_function_instance(usbg_function *f, struct test_function *tf) +{ + char str[USBG_MAX_NAME_LENGTH]; + int ret; + int small_len = 2; + + ret = usbg_cpy_function_instance(f, str, USBG_MAX_NAME_LENGTH); + assert_int_equal(ret, USBG_SUCCESS); + assert_string_equal(str, tf->instance); + + ret = usbg_cpy_function_instance(f, str, small_len); + assert_int_equal(ret, USBG_SUCCESS); + assert_memory_equal(str, tf->instance, small_len - 1); + assert_int_equal(str[small_len - 1], '\0'); +} + +/** + * @brief Tests copying function instance from usbg_function structure into buffer + * @param[in] state Pointer to pointer to correctly initialized state + * @details Check if buffer contains expected string + */ +static void test_cpy_function_instance(void **state) +{ + for_each_test_function(state, try_cpy_function_instance); +} + +/** + * @brief Get function type and check it + * @param[in] f Usbg function + * @param[in] tf Test function which should match f by type + */ +static void try_get_function_type(usbg_function *f, struct test_function *tf) +{ + usbg_function_type type; + + type = usbg_get_function_type(f); + assert_int_equal(type, tf->type); +} + +/** + * @brief Tests getting function type + * @details Check if getting function type returns what was expected. + * State must be proper (init must end with success). + * @param[in] state Pointer to pointer to correctly initialized state + */ +static void test_get_function_type(void **state) +{ + for_each_test_function(state, try_get_function_type); +} + +/** + * @brief Check if function instance length is correct + * @param[in] f Usbg function + * @param[in] tf Test function which should match f + */ +static void try_get_function_instance_len(usbg_function *f, struct test_function *tf) +{ + size_t len; + len = usbg_get_function_instance_len(f); + assert_int_equal(len, strlen(tf->instance)); +} + +/** + * @brief Tests getting length of function instance name + * @details Check if returned instance name length matches + * actual length of instance name + * @param[in] state Pointer to pointer to correctly initialized state + */ +static void test_get_function_instance_len(void **state) +{ + for_each_test_function(state, try_get_function_instance_len); +} + +/** * @brief cleanup usbg state */ static void teardown_state(void **state) @@ -544,6 +805,94 @@ static UnitTest tests[] = { */ USBG_TEST_TS("test_cpy_gadget_name_fail_simple", test_cpy_gadget_name_fail, setup_simple_state), + /** + * @usbg_test + * @test_desc{test_get_function_simple, + * Check if function can be correctly get from simple state, + * usbg_get_function} + */ + USBG_TEST_TS("test_get_function_simple", + test_get_function, setup_simple_state), + /** + * @usbg_test + * @test_desc{test_get_function_all_funcs, + * Check if getting function work on all function types, + * usbg_get_function} + */ + USBG_TEST_TS("test_get_function_all_funcs", + test_get_function, setup_all_funcs_state), + /** + * @usbg_test + * @test_desc{test_get_function_same_type_funcs, + * Check if having multiple functions with the same type does not + * cause failure + * usbg_get_function} + */ + USBG_TEST_TS("test_get_function_same_type_funcs", + test_get_function, setup_same_type_funcs_state), + /** + * @usbg_test + * @test_desc{test_get_function_fail_simple, + * Check if trying to get invalid function's name ends + * with expected error, + * usbg_get_function} + */ + USBG_TEST_TS("test_get_function_fail_simple", + test_get_function_fail, setup_simple_state), + /** + * @usbg_test + * @test_desc{test_get_function_instance_simple, + * Check if getting simple instance returns what expected, + * usbg_get_function_instance} + */ + USBG_TEST_TS("test_get_function_instance_simple", + test_get_function_instance, setup_simple_state), + /** + * @usbg_test + * @test_desc{test_cpy_function_instance_simple, + * Check if copying simple instance into buffer returns what expected, + * usbg_cpy_function_instance} + */ + USBG_TEST_TS("test_cpy_function_instance_simple", + test_cpy_function_instance, setup_all_funcs_state), + /** + * @usbg_test + * @test_desc{test_get_function_type_simple, + * Check if function type is returned correctly, + * usbg_get_function_type} + */ + USBG_TEST_TS("test_get_function_type_simple", + test_get_function_type, setup_simple_state), + /** + * @usbg_test + * @test_desc{test_get_function_type_all_funcs, + * Check if all function types are returned correctly, + * usbg_get_function_type} + */ + USBG_TEST_TS("test_get_function_type_all_funcs", + test_get_function_type, setup_all_funcs_state), + /** + * @usbg_test + * @test_desc{test_get_function_instance_len_simple, + * Check if function instance length is returned correctly, + * usbg_get_function_instance_len} + */ + USBG_TEST_TS("test_get_function_instance_len_simple", + test_get_function_instance_len, setup_simple_state), + /** + * @usbg_test + * @test_desc{test_get_function_type_str, + * Compare returned function types strings with expected values, + * usbg_get_function_type_str} + */ + unit_test(test_get_function_type_str), + /** + * @usbg_test + * @test_desc{test_get_function_type_str_fail, + * Try to get type string of unknown type, + * usbg_get_function_type_str} + */ + unit_test(test_get_function_type_str_fail), #ifndef DOXYGEN }; diff --git a/tests/usbg-test.c b/tests/usbg-test.c index e7ce209..ad053ce 100644 --- a/tests/usbg-test.c +++ b/tests/usbg-test.c @@ -431,3 +431,28 @@ void assert_path_equal(const char *actual, const char *expected) cast_to_largest_integral_type(expected)) == 0) fail(); } + +void for_each_test_function(void **state, FunctionTest fun) +{ + usbg_state *s = NULL; + struct test_state *ts; + struct test_gadget *tg; + struct test_function *tf; + usbg_gadget *g = NULL; + usbg_function *f = NULL; + + ts = (struct test_state *)(*state); + *state = NULL; + + init_with_state(ts, &s); + *state = s; + + for (tg = ts->gadgets; tg->name; ++tg) { + g = usbg_get_gadget(s, tg->name); + assert_non_null(g); + for (tf = tg->functions; tf->instance; ++tf) { + f = usbg_get_function(g, tf->type, tf->instance); + fun(f, tf); + } + } +} diff --git a/tests/usbg-test.h b/tests/usbg-test.h index b11f382..bd5742a 100644 --- a/tests/usbg-test.h +++ b/tests/usbg-test.h @@ -183,6 +183,16 @@ int path_equal_display_error(const LargestIntegralType actual, const LargestInte */ void assert_path_equal(const char *actual, const char *expected); +/** + * @brief Function that performs some test on given usbg function +*/ +typedef void (*FunctionTest)(usbg_function *f, struct test_function *tf); -#endif /* USBG_TEST_H */ +/** + * @brief Call given function for all usb functions present in given state + * @param[in] state Properly prepared state to be tested + * @param[in] fun Function to be called on each usb function in state + */ +void for_each_test_function(void **state, FunctionTest fun); +#endif /* USBG_TEST_H */