/**
* @testcase itc_wifimanager_connect_ap_config_p
* @brief check initialize, connect, de-initalization operations of wifi manager
* @scenario check initialize, connect, de-initalization operations of wifi manager
* @apicovered wifi_manager_init, wifi_manager_connect_ap_config, wifi_manager_deinit
* @precondition none
* @postcondition none
*/
static void itc_wifimanager_connect_ap_config_p(void)
{
wifi_manager_result_e ret = WIFI_MANAGER_FAIL;
ret = wifi_manager_init(&wifi_callbacks);
TC_ASSERT_EQ("wifi_manager_init", ret, WIFI_MANAGER_SUCCESS);
wifi_manager_ap_config_s config;
wifi_manager_reconnect_config_s reconfig;
reconfig.type = WIFI_RECONN_INTERVAL;
reconfig.interval = 10;
config.ssid_length = strlen(TEST_SSID);
config.passphrase_length = strlen(TEST_PASSWORD);
strncpy(config.ssid, TEST_SSID, config.ssid_length + 1);
strncpy(config.passphrase, TEST_PASSWORD, config.passphrase_length + 1);
config.ap_auth_type = (wifi_manager_ap_auth_type_e)TEST_AUTH_TYPE;
config.ap_crypto_type = (wifi_manager_ap_crypto_type_e)TEST_CRYPTO_TYPE;
printf("AP config: %s(%d), %s(%d), %d %d\n", config.ssid, config.ssid_length, config.passphrase, \
config.passphrase_length, config.ap_auth_type, config.ap_crypto_type);
ret = wifi_manager_connect_ap_config(&config, &reconfig);
TC_ASSERT_EQ_CLEANUP("wifi_manager_connect_ap", ret, WIFI_MANAGER_SUCCESS, wifi_manager_deinit());
WIFITEST_WAIT;
ret = wifi_manager_disconnect_ap();
TC_ASSERT_EQ_CLEANUP("wifi_manager_disconnect_ap", ret, WIFI_MANAGER_SUCCESS, wifi_manager_deinit());
WIFITEST_WAIT;
ret = wifi_manager_deinit();
TC_ASSERT_EQ("wifi_manager_deinit", ret, WIFI_MANAGER_SUCCESS);
TC_SUCCESS_RESULT();
}
/**
* @testcase itc_wifimanager_reremove_n
* @brief check initialize, save ap config, get ap config, remove ap config, de-initalization operations of wifi manager
* @scenario check initialize, save ap config, get ap config, remove ap config, de-initalization operations of wifi manager
* @apicovered wifi_manager_init, wifi_manager_save_config, wifi_manager_get_config, wifi_manager_remove_config wifi_manager_deinit
* @precondition none
* @postcondition none
*/
static void itc_wifimanager_reremove_n(void)
{
wifi_manager_result_e ret = WIFI_MANAGER_FAIL;
ret = wifi_manager_init(&wifi_callbacks);
TC_ASSERT_EQ("wifi_manager_init", ret, WIFI_MANAGER_SUCCESS);
wifi_manager_ap_config_s config;
wifi_manager_ap_config_s gconfig;
config.ssid_length = strlen(TEST_SSID);
config.passphrase_length = strlen(TEST_PASSWORD);
strncpy(config.ssid, TEST_SSID, config.ssid_length + 1);
strncpy(config.passphrase, TEST_PASSWORD, config.passphrase_length + 1);
config.ap_auth_type = (wifi_manager_ap_auth_type_e)TEST_AUTH_TYPE;
config.ap_crypto_type = (wifi_manager_ap_crypto_type_e)TEST_CRYPTO_TYPE;
printf("AP config: %s(%d), %s(%d), %d %d\n", config.ssid, config.ssid_length, config.passphrase, \
config.passphrase_length, config.ap_auth_type, config.ap_crypto_type);
ret = wifi_manager_save_config(&config);
TC_ASSERT_EQ_CLEANUP("wifi_manager_save_config", ret, WIFI_MANAGER_SUCCESS, wifi_manager_deinit());
ret = wifi_manager_get_config(&gconfig);
TC_ASSERT_EQ_CLEANUP("wifi_manager_get_config", ret, WIFI_MANAGER_SUCCESS, wifi_manager_deinit());
ret = wifi_manager_remove_config();
TC_ASSERT_EQ_CLEANUP("wifi_manager_remove_config", ret, WIFI_MANAGER_SUCCESS, wifi_manager_deinit());
ret = wifi_manager_remove_config();
TC_ASSERT_NEQ_CLEANUP("wifi_manager_remove_config", ret, WIFI_MANAGER_SUCCESS, wifi_manager_deinit());
ret = wifi_manager_deinit();
TC_ASSERT_EQ("wifi_manager_deinit", ret, WIFI_MANAGER_SUCCESS);
TC_SUCCESS_RESULT();
}
static void tc_pthread_pthread_yield(void)
{
int ret_chk = 0;
g_bpthreadcallback = false;
ret_chk = pthread_create(&g_thread1, NULL, thread_yield_callback, NULL);
TC_ASSERT_EQ("pthread_create", ret_chk, OK);
sleep(SEC_1);
TC_ASSERT_EQ_CLEANUP("pthread_yield", g_bpthreadcallback, true, pthread_detach(g_thread1));
ret_chk = pthread_create(&g_thread2, NULL, thread_yield_callback, NULL);
TC_ASSERT_EQ_CLEANUP("pthread_create", ret_chk, OK, pthread_detach(g_thread2));
TC_ASSERT_EQ_CLEANUP("pthread_create", g_bpthreadcallback, true, pthread_detach(g_thread2));
/* wait for threads to exit */
sleep(SEC_5);
ret_chk = pthread_join(g_thread1, NULL);
TC_ASSERT_EQ("pthread_join", ret_chk, OK);
ret_chk = pthread_join(g_thread2, NULL);
TC_ASSERT_EQ("pthread_join", ret_chk, OK);
TC_SUCCESS_RESULT();
}
/**
* @testcase itc_wifimanager_set_mode_p
* @brief to check get info operation of wifi manager
* @scenario check get info operation of wifi manager
* @apicovered wifi_manager_init, wifi_manager_set_mode, wifi_manager_get_info, wifi_manager_deinit
* @precondition none
* @postcondition none
*/
static void itc_wifimanager_set_mode_p(void)
{
wifi_manager_result_e ret = WIFI_MANAGER_FAIL;
ret = wifi_manager_init(&wifi_callbacks);
TC_ASSERT_EQ("wifi_manager_init", ret, WIFI_MANAGER_SUCCESS);
wifi_manager_softap_config_s ap_config;
strncpy(ap_config.ssid, TEST_SOFTAP_SSID,
strlen(TEST_SOFTAP_SSID) + 1);
ap_config.channel = TEST_SOFTAP_CHANNEL;
strncpy(ap_config.passphrase, TEST_SOFTAP_PASSWORD,
strlen(TEST_SOFTAP_PASSWORD) + 1);
printf("SoftAP config: %s(%d), %s(%d), %d\n", ap_config.ssid, strlen(TEST_SOFTAP_SSID),
ap_config.passphrase, strlen(TEST_SOFTAP_PASSWORD), ap_config.channel);
ret = wifi_manager_set_mode(SOFTAP_MODE, &ap_config);
TC_ASSERT_EQ_CLEANUP("wifi_manager_set_mode", ret, WIFI_MANAGER_SUCCESS, wifi_manager_deinit());
ret = wifi_manager_set_mode(STA_MODE, NULL);
TC_ASSERT_EQ_CLEANUP("wifi_manager_set_mode", ret, WIFI_MANAGER_SUCCESS, wifi_manager_deinit());
ret = wifi_manager_deinit();
TC_ASSERT_EQ("wifi_manager_deinit", ret, WIFI_MANAGER_SUCCESS);
TC_SUCCESS_RESULT();
}
/**
* @testcase itc_pwm_set_enabled_is_enabled_p
* @brief checks if pwm state is enabled
* @scenario sets and gets the same pwm period and checks if pwm state is enabled
* @apicovered iotbus_pwm_is_enabled
* @precondition opens the pwm_context
* @postcondition closes the pwm_context
*/
void itc_pwm_set_enabled_is_enabled_p(void)
{
int device = 0;
int channel = 1;
int period = 1000;
int ret = 0;
int default_state = 0;
int get_state = 0;
iotbus_pwm_context_h h_pwm = iotbus_pwm_open(device, channel);
TC_ASSERT_NOT_NULL("iotbus_pwm_open", h_pwm);
ret = iotbus_pwm_set_period(h_pwm, period);
TC_ASSERT_EQ_CLEANUP("iotbus_pwm_set_period", ret, OK, iotbus_pwm_close(h_pwm));
ret = iotbus_pwm_get_period(h_pwm);
TC_ASSERT_EQ_CLEANUP("iotbus_pwm_get_period", ret, period, iotbus_pwm_close(h_pwm));
default_state = iotbus_pwm_is_enabled(h_pwm);
TC_ASSERT_EQ_CLEANUP("iotbus_pwm_is_enabled", default_state < OK, false, iotbus_pwm_close(h_pwm));
iotbus_pwm_state_e e_state = IOTBUS_PWM_ENABLE;
if (default_state == IOTBUS_PWM_DISABLE) {
ret = iotbus_pwm_set_enabled(h_pwm, e_state);
TC_ASSERT_EQ_CLEANUP("iotbus_pwm_set_enabled", ret, OK, iotbus_pwm_close(h_pwm));
get_state = iotbus_pwm_is_enabled(h_pwm);
TC_ASSERT_EQ_CLEANUP("iotbus_pwm_is_enabled", get_state, e_state, iotbus_pwm_close(h_pwm); iotbus_pwm_set_enabled(h_pwm, default_state));
// Restoring default state
iotbus_pwm_set_enabled(h_pwm, default_state);
} else {
/**
* @testcase :itc_net_listen_p_multiple_time
* @brief :listen for socket connections and limit the queue of incoming connections
* @scenario :create socket, bind it and then listen and repeat multiple times
* @apicovered :listen()
* @precondition :open socket
* @postcondition :close socket
*/
static void itc_net_listen_p_multiple_time(void)
{
int index;
int socket_fd;
int ret;
struct sockaddr_in sa;
for (index = 0; index < LOOP_COUNT; index++) {
socket_fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
TC_ASSERT_GEQ("socket", socket_fd, CONFIG_NFILE_DESCRIPTORS);//If ASSERT FAILS, no need to close(socket_fd) as socket is not created
memset(&sa, 0, sizeof sa);
sa.sin_family = AF_INET;
sa.sin_port = htons(ADDR_PORT);
sa.sin_addr.s_addr = htonl(INADDR_ANY);
ret = bind(socket_fd, (struct sockaddr *)&sa, sizeof(sa));
TC_ASSERT_EQ_CLEANUP("bind", ret, 0, close(socket_fd));
ret = listen(socket_fd, BACK_LOG);
TC_ASSERT_EQ_CLEANUP("listen", ret, 0, close(socket_fd));
ret = close(socket_fd);
TC_ASSERT_EQ("close", ret, 0);
}
TC_SUCCESS_RESULT();
}
/**
* @testcase itc_systemio_iotbus_uart_set_mode_flush_write_read_p
* @brief To check flush/write/read operation with different parity
* @scenario uart flush/write/read operation with different parity
* @apicovered iotbus_uart_set_mode, iotbus_uart_write, iotbus_uart_read, iotbus_uart_flush
* @precondition initializes uart_context
* @postcondition closes uart_context
*/
static void itc_systemio_iotbus_uart_set_mode_flush_write_read_p(void)
{
int i_bytesize = 8;
int i_stop_bits = 1;
int ret = IOTBUS_ERROR_NONE;
char sz_input_text[BUF_LEN] = "UART READ/WRITE ITC TESTING!";
char sz_output_text[BUF_LEN];
int mode[] = { IOTBUS_UART_PARITY_NONE, IOTBUS_UART_PARITY_EVEN, IOTBUS_UART_PARITY_ODD };
char *mode_str[3] = { "IOTBUS_UART_PARITY_NONE", "IOTBUS_UART_PARITY_EVEN", "IOTBUS_UART_PARITY_ODD" };
int i_modes = sizeof(mode) / sizeof(int);
int index = 0;
int count_fail_mode = 0;
int count_fail_write = 0;
int count_fail_read = 0;
int count_fail_flush = 0;
iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);
for (index = 0; index < i_modes; index++) {
ret = iotbus_uart_set_mode(h_uart, i_bytesize, mode[index], i_stop_bits);
if ((ret != IOTBUS_ERROR_NONE)) {
SYSIO_ITC_PRINT("iotbus_uart_set_mode failed with PARITY ::%s, stop_bits::%d\n", mode_str[index], i_stop_bits);
count_fail_mode++;
continue;
}
ret = iotbus_uart_flush(h_uart);
if ((ret != IOTBUS_ERROR_NONE)) {
SYSIO_ITC_PRINT("iotbus_uart_flush failed with PARITY ::%s, stop_bits::%d\n", mode_str[index], i_stop_bits);
count_fail_flush++;
continue;
}
ret = iotbus_uart_write(h_uart, sz_input_text, sizeof(sz_input_text));
if ((ret < 0)) {
SYSIO_ITC_PRINT("iotbus_uart_write failed with PARITY ::%s, stop_bits::%d\n", mode_str[index], i_stop_bits);
count_fail_write++;
continue;
}
usleep(MICROSECOND);
ret = iotbus_uart_read(h_uart, sz_output_text, sizeof(sz_output_text));
if ((ret < 0) || (strcmp(sz_input_text, sz_output_text) != 0)) {
SYSIO_ITC_PRINT("iotbus_uart_read failed with PARITY ::%s, stop_bits::%d\n", mode_str[index], i_stop_bits);
count_fail_read++;
}
}
TC_ASSERT_EQ_CLEANUP("iotbus_uart_set_mode failed count", count_fail_mode, 0, iotbus_uart_stop(h_uart));
TC_ASSERT_EQ_CLEANUP("iotbus_uart_flush failed count", count_fail_flush, 0, iotbus_uart_stop(h_uart));
TC_ASSERT_EQ_CLEANUP("iotbus_uart_write failed count", count_fail_write, 0, iotbus_uart_stop(h_uart));
TC_ASSERT_EQ_CLEANUP("iotbus_uart_read failed count", count_fail_read, 0, iotbus_uart_stop(h_uart));
ret = iotbus_uart_stop(h_uart);
TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);
TC_SUCCESS_RESULT();
}
/**
* @testcase itc_systemio_iotbus_uart_write_read_flush_read_p
* @brief perform write, read, flush, and read data operations over uart bus
* @scenario perform write, read, flush, and read data operations over uart bus
* @apicovered iotbus_uart_write, iotbus_uart_read, iotbus_uart_flush
* @precondition initializes uart_context
* @postcondition closes uart_context
*/
static void itc_systemio_iotbus_uart_write_read_flush_read_p(void)
{
int ret = IOTBUS_ERROR_NONE;
char sz_input_text[BUF_LEN] = "UART READ/WRITE ITC TESTING!";
char sz_output_text[BUF_LEN];
iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);
ret = iotbus_uart_write(h_uart, sz_input_text, sizeof(sz_input_text));
TC_ASSERT_EQ_CLEANUP("iotbus_uart_write", ret < 0, false, iotbus_uart_stop(h_uart));
usleep(MICROSECOND);
ret = iotbus_uart_read(h_uart, sz_output_text, sizeof(sz_output_text));
TC_ASSERT_EQ_CLEANUP("iotbus_uart_read", ret < 0, false, iotbus_uart_stop(h_uart));
TC_ASSERT_EQ_CLEANUP("iotbus_uart_read", strcmp(sz_input_text, sz_output_text), 0, iotbus_uart_stop(h_uart));
ret = iotbus_uart_flush(h_uart);
TC_ASSERT_EQ_CLEANUP("iotbus_uart_flush", ret, IOTBUS_ERROR_NONE, iotbus_uart_stop(h_uart));
ret = iotbus_uart_read(h_uart, sz_output_text, sizeof(sz_output_text));
TC_ASSERT_EQ_CLEANUP("iotbus_uart_read", ret == 0, true, iotbus_uart_stop(h_uart));
ret = iotbus_uart_stop(h_uart);
TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);
TC_SUCCESS_RESULT();
}
/**
* @testcase itc_wifimanager_redisconnect_p
* @brief check disconnect operation if AP already disconnected
* @scenario check disconnect operation if AP already disconnected
* @apicovered wifi_manager_init, wifi_manager_set_mode, wifi_manager_connect_ap, wifi_manager_disconnect_ap, wifi_manager_deinit
* @precondition none
* @postcondition none
*/
static void itc_wifimanager_redisconnect_p(void)
{
wifi_manager_result_e ret = WIFI_MANAGER_FAIL;
ret = wifi_manager_init(&wifi_callbacks);
TC_ASSERT_EQ("wifi_manager_init", ret, WIFI_MANAGER_SUCCESS);
wifi_manager_ap_config_s config;
config.ssid_length = strlen(TEST_SSID);
config.passphrase_length = strlen(TEST_PASSWORD);
strncpy(config.ssid, TEST_SSID, config.ssid_length + 1);
strncpy(config.passphrase, TEST_PASSWORD, config.passphrase_length + 1);
config.ap_auth_type = (wifi_manager_ap_auth_type_e)TEST_AUTH_TYPE;
config.ap_crypto_type = (wifi_manager_ap_crypto_type_e)TEST_CRYPTO_TYPE;
printf("AP config: %s(%d), %s(%d), %d %d\n", config.ssid, config.ssid_length, config.passphrase, \
config.passphrase_length, config.ap_auth_type, config.ap_crypto_type);
ret = wifi_manager_connect_ap(&config);
TC_ASSERT_EQ_CLEANUP("wifi_manager_connect_ap", ret, WIFI_MANAGER_SUCCESS, wifi_manager_deinit());
WIFITEST_WAIT;
ret = wifi_manager_disconnect_ap();
TC_ASSERT_EQ_CLEANUP("wifi_manager_disconnect_ap", ret, WIFI_MANAGER_SUCCESS, wifi_manager_deinit());
WIFITEST_WAIT;
ret = wifi_manager_disconnect_ap();
TC_ASSERT_EQ_CLEANUP("wifi_manager_disconnect_ap", ret, WIFI_MANAGER_FAIL, wifi_manager_deinit());
// wifitest_wait is not required here, as it is already disconnected
ret = wifi_manager_deinit();
TC_ASSERT_EQ("wifi_manager_deinit", ret, WIFI_MANAGER_SUCCESS);
TC_SUCCESS_RESULT();
}
/**
* @testcase itc_systemio_iotbus_uart_set_flow_write_flush_read_p
* @brief flush, write, and read data over uart bus with set flow
* @scenario flush, write, and read data over uart bus with set flow
* @apicovered iotbus_uart_write, iotbus_uart_read, iotbus_uart_set_flowcontrol, iotbus_uart_flush
* @precondition initializes uart_context
* @postcondition closes uart_context
*/
static void itc_systemio_iotbus_uart_set_flow_flush_write_read_p(void)
{
int i_size = 4;
int ret = IOTBUS_ERROR_NONE;
char sz_input_text[BUF_LEN] = "UART READ/WRITE ITC TESTING!";
char sz_output_text[BUF_LEN];
int rtscts[4][2] = { {1, 0}, {0, 1}, {1, 1}, {0, 0} };
int index = 0;
int count_fail_flowcontrol = 0;
int count_fail_write = 0;
int count_fail_read = 0;
int count_fail_flush = 0;
iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);
for (index = 0; index < i_size; index++) {
ret = iotbus_uart_set_flowcontrol(h_uart, rtscts[index][0], rtscts[index][1]);
if (ret != IOTBUS_ERROR_NONE) {
SYSIO_ITC_PRINT("iotbus_uart_set_flowcontrol failed with xonxoff ::%d, rtscts::%d\n", rtscts[index][0], rtscts[index][1]);
count_fail_flowcontrol++;
continue;
}
ret = iotbus_uart_flush(h_uart);
if (ret != IOTBUS_ERROR_NONE) {
SYSIO_ITC_PRINT("iotbus_uart_flush failed with xonxoff ::%d, rtscts::%d\n", rtscts[index][0], rtscts[index][1]);
count_fail_flush++;
continue;
}
ret = iotbus_uart_write(h_uart, sz_input_text, sizeof(sz_input_text));
if (ret < 0) {
SYSIO_ITC_PRINT("iotbus_uart_write failed with xonxoff ::%d, rtscts::%d\n", rtscts[index][0], rtscts[index][1]);
count_fail_write++;
continue;
}
usleep(MICROSECOND);
ret = iotbus_uart_read(h_uart, sz_output_text, sizeof(sz_output_text));
if ((ret < 0) || (strcmp(sz_input_text, sz_output_text) != 0)) {
SYSIO_ITC_PRINT("iotbus_uart_read failed with xonxoff ::%d, rtscts::%d\n", rtscts[index][0], rtscts[index][1]);
count_fail_read++;
}
}
TC_ASSERT_EQ_CLEANUP("iotbus_uart_flush failed count", count_fail_flush, 0, iotbus_uart_stop(h_uart));
TC_ASSERT_EQ_CLEANUP("iotbus_uart_write failed count", count_fail_write, 0, iotbus_uart_stop(h_uart));
TC_ASSERT_EQ_CLEANUP("iotbus_uart_read failed count", count_fail_read, 0, iotbus_uart_stop(h_uart));
TC_ASSERT_EQ_CLEANUP("iotbus_uart_set_flowcontrol failed count", count_fail_flowcontrol, 0, iotbus_uart_stop(h_uart));
ret = iotbus_uart_stop(h_uart);
TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);
TC_SUCCESS_RESULT();
}
/**
* @testcase itc_systemio_iotbus_uart_set_mode_p_all
* @brief sets byte size, parity bit and stop bits (all combinations)
* @scenario sets byte size, parity bit and stop bits (all combinations)
* @apicovered iotbus_uart_set_mode
* @precondition initializes uart_context
* @postcondition closes uart_context
*/
static void itc_systemio_iotbus_uart_set_mode_p_all(void)
{
int i_bytesize = 0;
int i_max_bytesize = 10;
int i_stop_bits = 0;
int i_max_stop_bits = 4;
int ret = IOTBUS_ERROR_NONE;
int mode[] = { IOTBUS_UART_PARITY_NONE, IOTBUS_UART_PARITY_EVEN, IOTBUS_UART_PARITY_ODD };
char mode_str[3][BUF_LEN] = { "IOTBUS_UART_PARITY_NONE", "IOTBUS_UART_PARITY_EVEN", "IOTBUS_UART_PARITY_ODD" };
int i_modes = sizeof(mode) / sizeof(int);
int index = 0;
int count_bytesize_fail = 0;
int count_stopbit_fail = 0;
int count_fail = 0;
iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);
for (i_bytesize = 0; i_bytesize < i_max_bytesize; ++i_bytesize) {
for (i_stop_bits = 0; i_stop_bits < i_max_stop_bits; ++i_stop_bits) {
for (index = 0; index < i_modes; index++) {
ret = iotbus_uart_set_mode(h_uart, i_bytesize, mode[index], i_stop_bits);
if (i_stop_bits < 1 || i_stop_bits > 2) {
//checking for invalid parameters (stopbits)
if (ret != IOTBUS_ERROR_INVALID_PARAMETER) {
SYSIO_ITC_PRINT("iotbus_uart_set_mode failed for stopbits ::%d\n", i_stop_bits);
count_stopbit_fail++;
}
} else if (i_bytesize < 5 || i_bytesize > 8) {
//checking with invalid parameters (bytessize)
if (ret != IOTBUS_ERROR_INVALID_PARAMETER) {
SYSIO_ITC_PRINT("iotbus_uart_set_mode failed for bytesize ::%d\n", i_bytesize);
count_bytesize_fail++;
}
} else {
//checking with valid parameters
if (ret != IOTBUS_ERROR_NONE) {
SYSIO_ITC_PRINT("iotbus_uart_set_mode failed UART_PARITY::%s, bytesize::%d, stopbits::%d \n", mode_str[index], i_bytesize, i_stop_bits);
count_fail++;
}
}
}
}
}
TC_ASSERT_EQ_CLEANUP("iotbus_uart_set_mode fail_count with bytesize", count_bytesize_fail, 0, iotbus_uart_stop(h_uart));
TC_ASSERT_EQ_CLEANUP("iotbus_uart_set_mode fail_count with stopbit", count_stopbit_fail, 0, iotbus_uart_stop(h_uart));
TC_ASSERT_EQ_CLEANUP("iotbus_uart_set_mode fail_count", count_fail, 0, iotbus_uart_stop(h_uart));
ret = iotbus_uart_stop(h_uart);
TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);
TC_SUCCESS_RESULT();
}
static void tc_pthread_pthread_findjoininfo_destroyjoin(void)
{
int ret_chk;
g_bpthreadcallback = false;
ret_chk = pthread_create(&g_thread1, NULL, findjoininfo_callback, NULL);
TC_ASSERT_EQ_CLEANUP("pthread_create", ret_chk, OK, pthread_detach(g_thread1));
pthread_join(g_thread1, NULL);
TC_ASSERT_EQ_CLEANUP("pthread_join", g_bpthreadcallback, true, pthread_detach(g_thread1));
TC_SUCCESS_RESULT();
}
/**
* @testcase itc_wifimanager_connect_long_ssid_p
* @brief check connection with very long SSID
* @scenario check connection with very long SSID
* @apicovered wifi_manager_init, wifi_manager_set_mode, wifi_manager_connect_ap, wifi_manager_deinit
* @precondition none
* @postcondition none
*/
static void itc_wifimanager_connect_long_ssid_p(void)
{
const char ssid[] = "qwertyuiopalokasdasdjasdkajshdukekukzhjdshdkjsdksjdsdadsasdasdasd";
const char passphrase[] = "ashfdkjasfhkjsdhksahfkjdhsjfkhsdjahfkjashdfkjhasjkdhfkfdhksjafhsdaashdkjfksdhfkjashdjfhsajkdfh";
wifi_manager_result_e ret = WIFI_MANAGER_FAIL;
ret = wifi_manager_init(&wifi_callbacks);
TC_ASSERT_EQ("wifi_manager_init", ret, WIFI_MANAGER_SUCCESS);
wifi_manager_ap_config_s config;
config.ssid_length = strlen(ssid);
config.passphrase_length = strlen(passphrase);
strncpy(config.ssid, ssid, sizeof(config.ssid));
strncpy(config.passphrase, passphrase, sizeof(config.passphrase));
config.ap_auth_type = (wifi_manager_ap_auth_type_e)TEST_AUTH_TYPE;
config.ap_crypto_type = (wifi_manager_ap_crypto_type_e)TEST_CRYPTO_TYPE;
printf("AP config: %s(%d), %s(%d), %d %d\n", config.ssid, config.ssid_length, config.passphrase, \
config.passphrase_length, config.ap_auth_type, config.ap_crypto_type);
ret = wifi_manager_connect_ap(&config);
TC_ASSERT_EQ_CLEANUP("wifi_manager_connect_ap", ret, WIFI_MANAGER_INVALID_ARGS, wifi_manager_deinit());
ret = wifi_manager_deinit();
TC_ASSERT_EQ("wifi_manager_deinit", ret, WIFI_MANAGER_SUCCESS);
TC_SUCCESS_RESULT();
}
void itc_mqtt_subscribe_unsubscribe_p(void)
{
int res;
g_mqtt_client_handle = mqtt_init_client(&g_mqtt_client_config);
TC_ASSERT_NEQ("mqtt_init_client", g_mqtt_client_handle, NULL);
res = mqtt_connect(g_mqtt_client_handle, CONFIG_ITC_MQTT_BROKER_ADDR, CONFIG_ITC_MQTT_BROKER_PORT, 0);
TC_ASSERT_EQ_CLEANUP("mqtt_connect", res, 0, mqtt_deinit_client(g_mqtt_client_handle));
ITC_MQTT_WAIT_SIGNAL;
res = mqtt_subscribe(g_mqtt_client_handle, ITC_MQTT_TOPIC, 0);
TC_ASSERT_EQ_CLEANUP("mqtt_subscribe", res, 0,
mqtt_disconnect(g_mqtt_client_handle); mqtt_deinit_client(g_mqtt_client_handle));
res = mqtt_unsubscribe(g_mqtt_client_handle, ITC_MQTT_TOPIC);
TC_ASSERT_EQ_CLEANUP("mqtt_unsubscribe", res, 0,
mqtt_disconnect(g_mqtt_client_handle); mqtt_deinit_client(g_mqtt_client_handle));
res = mqtt_disconnect(g_mqtt_client_handle);
TC_ASSERT_EQ("mqtt_disconnect", res, 0);
ITC_MQTT_WAIT_SIGNAL;
res = mqtt_deinit_client(g_mqtt_client_handle);
TC_ASSERT_EQ("mqtt_deinit_client", res, 0);
TC_SUCCESS_RESULT();
}
/**
* @fn :tc_driver_adc_open_close
* @brief :Test the adc driver open and close
* @scenario :Test the adc driver open and close
* API's covered :open, close
* Preconditions :none
* Postconditions :none
* @return :void
*/
static void tc_driver_adc_open_close(void)
{
int fd = 0;
int ret = 0;
/* Positive test cases */
fd = open("/dev/adc0", O_RDONLY);
TC_ASSERT_GT("adc_open", fd, 0);
ret = close(fd);
TC_ASSERT_EQ("adc_close", ret, OK);
/* Negative test cases */
int count = 0;
int fds[255] = { 0, };
for (count = 0; count < 255; count++) {
fds[count] = open("/dev/adc0", O_RDONLY);
if (fds[count] < 0) {
TC_ASSERT_EQ_CLEANUP("adc_open", errno, EMFILE, close_fds(fds, --count));
break;
}
}
close_fds(fds, --count);
TC_SUCCESS_RESULT();
}
/**
* @testcase itc_wifimanager_connect_ap_n
* @brief connecting with invalid configuration parameters
* @scenario connecting with invalid configuration parameters
* @apicovered wifi_manager_init, wifi_manager_set_mode, wifi_manager_connect_ap, wifi_manager_deinit
* @precondition none
* @postcondition none
*/
static void itc_wifimanager_connect_ap_n(void)
{
char ssid[] = "";
char passphrase[] = "";
wifi_manager_result_e ret = WIFI_MANAGER_FAIL;
ret = wifi_manager_init(&wifi_callbacks);
TC_ASSERT_EQ("wifi_manager_init", ret, WIFI_MANAGER_SUCCESS);
wifi_manager_ap_config_s config;
config.ssid_length = strlen(ssid);
config.passphrase_length = strlen(passphrase);
strncpy(config.ssid, ssid, config.ssid_length + 1);
strncpy(config.passphrase, passphrase, config.passphrase_length + 1);
config.ap_auth_type = (wifi_manager_ap_auth_type_e)TEST_AUTH_TYPE;
config.ap_crypto_type = (wifi_manager_ap_crypto_type_e)TEST_CRYPTO_TYPE;
printf("AP config: %s(%d), %s(%d), %d %d\n", config.ssid, config.ssid_length, config.passphrase, \
config.passphrase_length, config.ap_auth_type, config.ap_crypto_type);
ret = wifi_manager_connect_ap(&config);
TC_ASSERT_EQ_CLEANUP("wifi_manager_connect_ap", ret, WIFI_MANAGER_FAIL, wifi_manager_deinit());
ret = wifi_manager_deinit();
TC_ASSERT_EQ("wifi_manager_deinit", ret, WIFI_MANAGER_SUCCESS);
TC_SUCCESS_RESULT();
}
/**
* @fn :tc_timer_timer_create_delete
* @brief :Create and delete a POSIX per-process timer
* @scenario :Create and delete a POSIX per-process timer
* API's covered :timer_create, timer_delete
* Preconditions :none
* Postconditions :none
* @return :void
*/
static void tc_timer_timer_create_delete(void)
{
int ret_chk = 0;
timer_t timer_id;
timer_t gtimer_id;
clockid_t clockid = CLOCK_REALTIME;
struct sigevent st_sigevent;
struct posix_timer_s *st_ret_prt;
struct itimerspec st_timer_spec_val;
/* Set and enable alarm */
st_sigevent.sigev_notify = SIGEV_SIGNAL;
st_sigevent.sigev_signo = sig_no;
st_sigevent.sigev_value.sival_ptr = &timer_id;
ret_chk = timer_create(clockid, &st_sigevent, &timer_id);
TC_ASSERT_NEQ("timer_create", ret_chk, ERROR);
TC_ASSERT_NOT_NULL("timer_create", timer_id);
st_ret_prt = (struct posix_timer_s *)timer_id;
TC_ASSERT_EQ_CLEANUP("timer_create", st_ret_prt->pt_value.sival_ptr, st_sigevent.sigev_value.sival_ptr, timer_delete(timer_id));
TC_ASSERT_EQ_CLEANUP("timer_create", st_ret_prt->pt_signo, st_sigevent.sigev_signo, timer_delete(timer_id));
TC_ASSERT_EQ_CLEANUP("timer_create", st_ret_prt->pt_crefs, 1, timer_delete(timer_id));
TC_ASSERT_EQ_CLEANUP("timer_create", st_ret_prt->pt_owner, getpid(), timer_delete(timer_id));
TC_ASSERT_EQ_CLEANUP("timer_create", st_ret_prt->pt_delay, 0, timer_delete(timer_id));
st_timer_spec_val.it_value.tv_sec = 1;
st_timer_spec_val.it_value.tv_nsec = 0;
st_timer_spec_val.it_interval.tv_sec = 1;
st_timer_spec_val.it_interval.tv_nsec = 0;
ret_chk = timer_settime(timer_id, 0, &st_timer_spec_val, NULL);
TC_ASSERT_EQ_ERROR_CLEANUP("timer_settime", ret_chk, OK, errno, timer_delete(timer_id));
ret_chk = timer_delete(timer_id);
TC_ASSERT_NEQ("timer_delete", ret_chk, ERROR);
ret_chk = timer_create(CLOCK_REALTIME, NULL, >imer_id);
TC_ASSERT_NEQ("timer_create", ret_chk, ERROR);
st_ret_prt = (struct posix_timer_s *)gtimer_id;
TC_ASSERT_EQ_CLEANUP("timer_create", st_ret_prt->pt_value.sival_ptr, st_ret_prt, timer_delete(gtimer_id));
TC_ASSERT_EQ_CLEANUP("timer_create", st_ret_prt->pt_crefs, 1, timer_delete(gtimer_id));
TC_ASSERT_EQ_CLEANUP("timer_create", st_ret_prt->pt_owner, getpid(), timer_delete(gtimer_id));
TC_ASSERT_EQ_CLEANUP("timer_create", st_ret_prt->pt_delay, 0, timer_delete(gtimer_id));
ret_chk = timer_delete(gtimer_id);
TC_ASSERT_NEQ("timer_delete", ret_chk, ERROR);
TC_SUCCESS_RESULT();
}
void itc_mqtt_connect_n_reconnect(void)
{
int res;
g_mqtt_client_handle = mqtt_init_client(&g_mqtt_client_config);
TC_ASSERT_NEQ("mqtt_init_client", g_mqtt_client_handle, NULL);
// MQTT Connect
res = mqtt_connect(g_mqtt_client_handle, CONFIG_ITC_MQTT_BROKER_ADDR, CONFIG_ITC_MQTT_BROKER_PORT, 0);
TC_ASSERT_EQ_CLEANUP("mqtt_connect", res, 0, mqtt_deinit_client(g_mqtt_client_handle));
ITC_MQTT_WAIT_SIGNAL;
// MQTT re-Connect
res = mqtt_connect(g_mqtt_client_handle, CONFIG_ITC_MQTT_BROKER_ADDR, CONFIG_ITC_MQTT_BROKER_PORT, 0);
TC_ASSERT_EQ_CLEANUP("mqtt_connect", res, 0, mqtt_deinit_client(g_mqtt_client_handle));
if (g_mqtt_client_handle != NULL) {
TC_ASSERT_EQ_CLEANUP("mqtt_connect", g_mqtt_client_handle->state, MQTT_CLIENT_STATE_CONNECTED,
mqtt_disconnect(g_mqtt_client_handle); mqtt_deinit_client(g_mqtt_client_handle));
}
/**
* @testcase itc_pwm_set_get_period_p
* @brief sets and gets the pwm period
* @scenario sets and gets the same pwm period
* @apicovered iotbus_pwm_set_period, iotbus_pwm_get_period
* @precondition opens the pwm_context
* @postcondition closes the pwm_context
*/
void itc_pwm_set_get_period_p(void)
{
int device = 0;
int channel = 1;
int period = 1000;
int ret = 0;
iotbus_pwm_context_h h_pwm = iotbus_pwm_open(device, channel);
TC_ASSERT_NOT_NULL("iotbus_pwm_open", h_pwm);
ret = iotbus_pwm_set_period(h_pwm, period);
TC_ASSERT_EQ_CLEANUP("iotbus_pwm_set_period", ret, OK, iotbus_pwm_close(h_pwm));
ret = iotbus_pwm_get_period(h_pwm);
TC_ASSERT_EQ_CLEANUP("iotbus_pwm_get_period", ret, period, iotbus_pwm_close(h_pwm));
ret = iotbus_pwm_close(h_pwm);
TC_ASSERT_EQ("iotbus_pwm_close", ret, OK);
TC_SUCCESS_RESULT();
}
/**
* @testcase itc_pwm_set_get_duty_cycle_p
* @brief sets and gets the pwm duty cycle
* @scenario sets and gets the same pwm duty cycle
* @apicovered iotbus_pwm_set_duty_cycle, iotbus_pwm_get_duty_cycle
* @precondition opens the pwm_context
* @postcondition closes the pwm_context
*/
void itc_pwm_set_get_duty_cycle_p(void)
{
int device = 0;
int channel = 1;
int cycle = 20;
int ret = 0;
iotbus_pwm_context_h h_pwm = iotbus_pwm_open(device, channel);
TC_ASSERT_NOT_NULL("iotbus_pwm_open", h_pwm);
ret = iotbus_pwm_set_duty_cycle(h_pwm, cycle);
TC_ASSERT_EQ_CLEANUP("iotbus_pwm_set_duty_cycle", ret, OK, iotbus_pwm_close(h_pwm));
ret = iotbus_pwm_get_duty_cycle(h_pwm);
TC_ASSERT_EQ_CLEANUP("iotbus_pwm_get_duty_cycle", ret, cycle, iotbus_pwm_close(h_pwm));
ret = iotbus_pwm_close(h_pwm);
TC_ASSERT_EQ("iotbus_pwm_close", ret, OK);
TC_SUCCESS_RESULT();
}
static void utc_taskmanager_getinfo_with_pid_p(void)
{
tm_appinfo_t *ret;
ret = task_manager_getinfo_with_pid(pid_tm_utc, TM_RESPONSE_WAIT_INF);
TC_ASSERT_NEQ_CLEANUP("task_manager_getinfo_with_pid", ret, NULL, task_manager_clean_info(&ret));
TC_ASSERT_EQ_CLEANUP("task_manager_getinfo_with_pid", ret->handle, handle_tm_utc, task_manager_clean_info(&ret));
(void)task_manager_clean_info(&ret);
TC_SUCCESS_RESULT();
}
/**
* @fn :tc_pthread_pthread_kill
* @brief :send a signal to a thread
* @Scenario :The pthread_kill() function sends the signal sig to thread, a thread
* in the same process as the caller. The signal is asynchronously
* directed to thread.
* API's covered :pthread_kill, pthread_join
* Preconditions :none
* Postconditions :none
* @return :void
*/
static void tc_pthread_pthread_kill(void)
{
int ret_chk;
g_bpthreadcallback = false;
ret_chk = pthread_create(&g_thread1, NULL, thread_kill_func_callback, NULL);
if (ret_chk != OK) {
tckndbg("ERROR pthread_create FAIL\n");
pthread_detach(g_thread1);
}
sleep(SEC_2);
ret_chk = pthread_kill(g_thread1, SIGUSR1);
sleep(SEC_1);
TC_ASSERT_EQ_CLEANUP("pthread_kill", ret_chk, OK, pthread_detach(g_thread1));
TC_ASSERT_EQ_CLEANUP("pthread_kill", g_bpthreadcallback, true, pthread_detach(g_thread1));
pthread_join(g_thread1, NULL);
TC_SUCCESS_RESULT();
}
/**
* @fn :tc_pthread_pthread_cancel_setcancelstate
* @brief :set cancelability state and type and sends a cancellation request to a thread
* @Scenario :The pthread_setcancelstate() sets the cancelability state of the calling
* thread to the value given in state. The pthread_cancel() function sends a cancellation request to the thread thread.
* Whether and when the target thread reacts to the cancellation request depends
* on two attributes that are under the control of that thread:
* its cancelability state and type
* API's covered :pthread_setcancelstate, pthread_cancel
* Preconditions :none
* Postconditions :none
* @return :void
*/
static void tc_pthread_pthread_cancel_setcancelstate(void)
{
int ret_chk;
g_bpthreadcallback = false;
ret_chk = pthread_create(&g_thread1, NULL, cancel_state_func, NULL);
TC_ASSERT_EQ_CLEANUP("pthread_create", ret_chk, OK, pthread_detach(g_thread1));
sleep(SEC_1);
/* this cancel request goes to pending if cancel is disabled */
ret_chk = pthread_cancel(g_thread1);
TC_ASSERT_EQ_CLEANUP("pthread_cancel", ret_chk, OK, pthread_detach(g_thread1));
sleep(SEC_3);
TC_ASSERT("pthread_cancel", g_bpthreadcallback);
ret_chk = pthread_detach(g_thread1);
TC_ASSERT_EQ("pthread_detach", ret_chk, OK);
TC_SUCCESS_RESULT();
}
/**
* @testcase itc_wifimanager_average_stoping_ap
* @brief to check average time taken while deinit wifi
* @scenario to check average time taken while deinit wifi
* @apicovered wifi_manager_init, wifi_manager_set_mode, wifi_manager_connect_ap, wifi_manager_disconnect_ap, wifi_manager_deinit
* @precondition none
* @postcondition none
*/
static void itc_wifimanager_average_stoping_ap(void)
{
int i = 0;
double average = 0.0f;
struct timeval start_t;
struct timeval end_t;
wifi_manager_result_e ret = WIFI_MANAGER_FAIL;
wifi_manager_ap_config_s config;
config.ssid_length = strlen(TEST_SSID);
config.passphrase_length = strlen(TEST_PASSWORD);
strncpy(config.ssid, TEST_SSID, config.ssid_length + 1);
strncpy(config.passphrase, TEST_PASSWORD, config.passphrase_length + 1);
config.ap_auth_type = (wifi_manager_ap_auth_type_e)TEST_AUTH_TYPE;
config.ap_crypto_type = (wifi_manager_ap_crypto_type_e)TEST_CRYPTO_TYPE;
printf("AP config: %s(%d), %s(%d), %d %d\n", config.ssid, config.ssid_length, config.passphrase, \
config.passphrase_length, config.ap_auth_type, config.ap_crypto_type);
for (i = 1; i <= LOOP_SIZE; i++) {
ret = wifi_manager_init(&wifi_callbacks);
TC_ASSERT_EQ("wifi_manager_init", ret, WIFI_MANAGER_SUCCESS);
ret = wifi_manager_connect_ap(&config);
TC_ASSERT_EQ_CLEANUP("wifi_manager_connect_ap", ret, WIFI_MANAGER_SUCCESS, wifi_manager_deinit());
WIFITEST_WAIT;
ret = wifi_manager_disconnect_ap();
TC_ASSERT_EQ_CLEANUP("wifi_manager_disconnect_ap", ret, WIFI_MANAGER_SUCCESS, wifi_manager_deinit());
WIFITEST_WAIT;
gettimeofday(&start_t, NULL);
ret = wifi_manager_deinit();
TC_ASSERT_EQ("wifi_manager_deinit", ret, WIFI_MANAGER_SUCCESS);
gettimeofday(&end_t, NULL);
average += diff_time(&start_t, &end_t);
}
printf("\n[Average wifi deinitialization time: %.2f ms]\n", average / (LOOP_SIZE * 1000));
TC_SUCCESS_RESULT();
}
/**
* @fn :tc_pthread_pthread_set_get_schedparam
* @brief :set/get scheduling policy and parameters of a thread
* @Scenario :The pthread_setschedparam() function sets the scheduling policy and
* parameters of the thread , Policy specifies the new scheduling policy for thread.
* The pthread_getschedparam() function returns the scheduling policy and parameters
* of the thread thread, in the buffers pointed to by policy and param, respectively.
* API's covered :pthread_setschedparam, pthread_getschedparam
* Preconditions :none
* Postconditions :none
* @return :void
*/
static void tc_pthread_pthread_set_get_schedparam(void)
{
int ret_chk;
struct sched_param st_setparam;
struct sched_param st_getparam;
int getpolicy;
int setpolicy = SCHED_FIFO;
memset(&st_setparam, 0, sizeof(st_setparam));
st_setparam.sched_priority = SCHED_PRIORITY;
ret_chk = pthread_create(&g_thread1, NULL, threadfunc_sched, NULL);
TC_ASSERT_EQ_CLEANUP("pthread_create", ret_chk, OK, pthread_detach(g_thread1));
sleep(SEC_2);
ret_chk = pthread_setschedparam(g_thread1, setpolicy, &st_setparam);
TC_ASSERT_EQ_CLEANUP("pthread_setschedparam", ret_chk, OK, pthread_detach(g_thread1));
sleep(SEC_1);
ret_chk = pthread_getschedparam(g_thread1, &getpolicy, &st_getparam);
TC_ASSERT_EQ_CLEANUP("pthread_getschedparam", ret_chk, OK, pthread_detach(g_thread1));
TC_ASSERT_EQ_CLEANUP("pthread_getschedparam", getpolicy, setpolicy, pthread_detach(g_thread1));
TC_ASSERT_EQ_CLEANUP("pthread_getschedparam", st_getparam.sched_priority, st_setparam.sched_priority, pthread_detach(g_thread1));
ret_chk = pthread_join(g_thread1, NULL);
TC_ASSERT_EQ_CLEANUP("pthread_join", ret_chk, OK, pthread_detach(g_thread1));
TC_SUCCESS_RESULT();
}
void itc_mqtt_publish_p(void)
{
int res;
g_mqtt_client_handle = mqtt_init_client(&g_mqtt_client_config);
TC_ASSERT_NEQ("mqtt_init_client", g_mqtt_client_handle, NULL);
res = mqtt_connect(g_mqtt_client_handle, CONFIG_ITC_MQTT_BROKER_ADDR, CONFIG_ITC_MQTT_BROKER_PORT, 0);
TC_ASSERT_EQ_CLEANUP("mqtt_connect", res, 0, mqtt_deinit_client(g_mqtt_client_handle));
ITC_MQTT_WAIT_SIGNAL;
res = mqtt_publish(g_mqtt_client_handle, ITC_MQTT_TOPIC, g_mqtt_msg, sizeof(g_mqtt_msg), 0, 0);
TC_ASSERT_EQ_CLEANUP("mqtt_publish", res, 0,
mqtt_disconnect(g_mqtt_client_handle); mqtt_deinit_client(g_mqtt_client_handle));
ITC_MQTT_WAIT_SIGNAL;
res = mqtt_disconnect(g_mqtt_client_handle);
TC_ASSERT_EQ_CLEANUP("mqtt_disconnect", res, 0, mqtt_deinit_client(g_mqtt_client_handle));
ITC_MQTT_WAIT_SIGNAL;
res = mqtt_deinit_client(g_mqtt_client_handle);
TC_ASSERT_EQ("mqtt_deinit_client", res, 0);
TC_SUCCESS_RESULT();
}
/**
* @fn :tc_pthread_pthread_set_getspecific
* @brief :thread-specific data management
* @Scenario :The pthread_getspecific() function shall return the value currently bound
* to the specified key on behalf of the calling thread.
* The pthread_setspecific() function shall associate a thread-specific value
* with a key obtained via a previous call to pthread_key_create().
* API's covered :pthread_setspecific, pthread_getspecific, pthread_key_create
* Preconditions :pthread_key_create
* Postconditions :none
* @return :void
*/
static void tc_pthread_pthread_key_create_set_getspecific(void)
{
int ret_chk;
g_bpthreadcallback = false;
g_tlskey = 0;
/* Cannot create keys more than PTHREAD_KEYS_MAX, Not able to delete key */
ret_chk = pthread_key_create(&g_tlskey, NULL);
TC_ASSERT_EQ("pthread_key_create", ret_chk, OK);
sleep(SEC_2);
ret_chk = pthread_create(&g_thread1, NULL, func_set_get_callback, NULL);
TC_ASSERT_EQ_CLEANUP("pthread_create", ret_chk, OK, pthread_detach(g_thread1));
ret_chk = pthread_join(g_thread1, NULL);
TC_ASSERT_EQ_CLEANUP("pthread_join", ret_chk, OK, pthread_detach(g_thread1));
TC_ASSERT_EQ("pthread_join", g_bpthreadcallback, true);
TC_SUCCESS_RESULT();
}
/**
* @testcase itc_wifimanager_connect_set_mode_n
* @brief set mode with NULL config
* @scenario set mode with NULL config
* @apicovered wifi_manager_set_mode, wifi_manager_init, wifi_manager_deinit
* @precondition none
* @postcondition none
*/
static void itc_wifimanager_connect_set_mode_n(void)
{
wifi_manager_result_e ret = WIFI_MANAGER_FAIL;
ret = wifi_manager_init(&wifi_callbacks);
TC_ASSERT_EQ("wifi_manager_init", ret, WIFI_MANAGER_SUCCESS);
ret = wifi_manager_set_mode(SOFTAP_MODE, NULL);
TC_ASSERT_EQ_CLEANUP("wifi_manager_set_mode", ret, WIFI_MANAGER_INVALID_ARGS, wifi_manager_deinit());
ret = wifi_manager_deinit();
TC_ASSERT_EQ("wifi_manager_deinit", ret, WIFI_MANAGER_SUCCESS);
TC_SUCCESS_RESULT();
}
/**
* @testcase itc_systemio_iotbus_uart_flush_p
* @brief flushes uart buffer
* @scenario flushes uart buffer
* @apicovered iotbus_uart_flush
* @precondition initializes uart_context
* @postcondition closes uart_context
*/
void itc_systemio_iotbus_uart_flush_p(void)
{
int ret = IOTBUS_ERROR_NONE;
iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);
ret = iotbus_uart_flush(h_uart);
TC_ASSERT_EQ_CLEANUP("iotbus_uart_flush", ret, IOTBUS_ERROR_NONE, iotbus_uart_stop(h_uart));
ret = iotbus_uart_stop(h_uart);
TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);
TC_SUCCESS_RESULT();
}
static void utc_taskmanager_unicast_n(void)
{
int ret;
tm_msg_t send_msg;
send_msg.msg_size = strlen(TM_SAMPLE_MSG) + 1;
send_msg.msg = malloc(send_msg.msg_size);
TC_ASSERT_NEQ("task_manager_unicast", send_msg.msg, NULL);
strncpy(send_msg.msg, TM_SAMPLE_MSG, send_msg.msg_size);
ret = task_manager_unicast(tm_sample_handle, &send_msg, NULL, TM_INVALID_TIMEOUT);
TC_ASSERT_EQ_CLEANUP("task_manager_unicast", ret, TM_INVALID_PARAM, free(send_msg.msg));
ret = task_manager_unicast(TM_INVALID_HANDLE, &send_msg, NULL, TM_NO_RESPONSE);
TC_ASSERT_EQ_CLEANUP("task_manager_unicast", ret, TM_INVALID_PARAM, free(send_msg.msg));
send_msg.msg_size = 0;
ret = task_manager_unicast(tm_sample_handle, &send_msg, NULL, TM_NO_RESPONSE);
TC_ASSERT_EQ_CLEANUP("task_manager_unicast", ret, TM_INVALID_PARAM, free(send_msg.msg));
free(send_msg.msg);
TC_SUCCESS_RESULT();
}
