static void tc_pthread_pthread_sigmask(void)
{
int ret_chk;
pid_t pid = getpid();
sigset_t st_newmask;
sigset_t st_oldmask;
sigset_t st_pendmask;
struct timespec st_timespec;
struct sigaction st_act;
struct sigaction st_oact;
g_sig_handle = false;
st_timespec.tv_sec = SEC_5;
st_timespec.tv_nsec = 0;
memset(&st_act, 0, sizeof(st_act));
st_act.sa_handler = sigmask_handler;
ret_chk = sigaction(SIGQUIT, &st_act, &st_oact);
TC_ASSERT_EQ("signaction", ret_chk, OK);
sigemptyset(&st_newmask);
sigaddset(&st_newmask, SIGQUIT);
ret_chk = pthread_sigmask(SIG_BLOCK, &st_newmask, &st_oldmask);
TC_ASSERT_GEQ("pthread_sigmask", ret_chk, 0);
nanosleep(&st_timespec, NULL);
kill(pid, SIGQUIT);
/* to call the handler function for verifying the sigpromask */
ret_chk = pthread_sigmask(SIG_SETMASK, &st_oldmask, NULL);
TC_ASSERT_GEQ("pthread_sigmask", ret_chk, 0);
st_timespec.tv_sec = 1;
nanosleep(&st_timespec, NULL);
ret_chk = pthread_sigmask(SIG_UNBLOCK, &st_oldmask, NULL);
TC_ASSERT_GEQ("pthread_sigmask", ret_chk, 0);
ret_chk = sigpending(&st_pendmask);
TC_ASSERT_GEQ("sigpending", ret_chk, 0);
nanosleep(&st_timespec, NULL);
TC_ASSERT("pthread_sigmask", g_sig_handle);
ret_chk = sigaction(SIGQUIT, &st_oact, NULL);
TC_ASSERT_EQ("signaction", ret_chk, OK);
TC_SUCCESS_RESULT();
}
static void utc_taskmanager_register_task_p(void)
{
tm_not_builtin_handle = task_manager_register_task("not_builtin", 100, 1024, not_builtin_task, NULL, TM_APP_PERMISSION_DEDICATE, TM_RESPONSE_WAIT_INF);
TC_ASSERT_GEQ("task_manager_register_task", tm_not_builtin_handle, 0);
TC_SUCCESS_RESULT();
}
static void utc_taskmanager_alloc_broadcast_msg_p(void)
{
tm_broadcast_undefined_msg = task_manager_alloc_broadcast_msg();
TC_ASSERT_GEQ("task_manager_alloc_broadcast_msg", tm_broadcast_undefined_msg, 0);
TC_SUCCESS_RESULT();
}
void tc_fs_smartfs_procfs_main(void)
{
int fd;
int ret;
struct stat st;
fd = open(PROC_SMARTFS_PATH, O_RDONLY);
TC_ASSERT_GEQ("open", fd, 0);
ret = close(fd);
TC_ASSERT_EQ("close", ret, OK);
/* entry not found condition */
fd = open(PROC_SMARTFS_FILE_PATH, O_RDWR | O_CREAT);
TC_ASSERT_EQ("open", fd, ERROR);
fd = open(INVALID_PATH, O_RDONLY);
TC_ASSERT_EQ("open", fd, ERROR);
ret = read_dir_entries(PROC_SMARTFS_PATH);
TC_ASSERT_EQ("read_dir_entries", ret, OK);
ret = stat(PROC_SMARTFS_PATH, &st);
TC_ASSERT_EQ("stat", ret, OK);
TC_SUCCESS_RESULT();
}
/**
* @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();
}
static void utc_taskmanager_register_pthread_p(void)
{
pthread_attr_t attr;
pthread_attr_init(&attr);
tm_pthread_handle = task_manager_register_pthread("tm_pthread", &attr, tm_pthread, NULL, TM_APP_PERMISSION_DEDICATE, TM_RESPONSE_WAIT_INF);
TC_ASSERT_GEQ("task_manager_register_pthread", tm_pthread_handle, 0);
TC_SUCCESS_RESULT();
}
static void utc_taskmanager_register_p(void)
{
tm_sample_handle = task_manager_register_builtin("invalid", TM_APP_PERMISSION_DEDICATE, TM_RESPONSE_WAIT_INF);
TC_ASSERT_EQ("task_manager_register", tm_sample_handle, TM_OPERATION_FAIL);
tm_sample_handle = task_manager_register_builtin(TM_SAMPLE_NAME, TM_APP_PERMISSION_DEDICATE, TM_RESPONSE_WAIT_INF);
TC_ASSERT_GEQ("task_manager_register", tm_sample_handle, 0);
tm_broadcast_handle1 = task_manager_register_builtin(TM_BROADCAST1_NAME, TM_APP_PERMISSION_DEDICATE, TM_RESPONSE_WAIT_INF);
TC_ASSERT_GEQ("task_manager_register", tm_broadcast_handle1, 0);
tm_broadcast_handle2 = task_manager_register_builtin(TM_BROADCAST2_NAME, TM_APP_PERMISSION_DEDICATE, TM_RESPONSE_WAIT_INF);
TC_ASSERT_GEQ("task_manager_register", tm_broadcast_handle2, 0);
tm_broadcast_handle3 = task_manager_register_builtin(TM_BROADCAST3_NAME, TM_APP_PERMISSION_DEDICATE, TM_RESPONSE_WAIT_INF);
TC_ASSERT_GEQ("task_manager_register", tm_broadcast_handle3, 0);
TC_SUCCESS_RESULT();
}
/**
* @testcase :itc_net_listen_p_different_socket
* @brief :listen for socket connections and limit the queue of incoming connections
* @scenario :create socket, bind it and then listen
* @apicovered :listen()
* @precondition :open socket
* @postcondition :close socket
*/
static void itc_net_listen_p_different_socket(void)
{
struct sockaddr_in sa;
struct sockaddr_in saddr;
int socket_fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
TC_ASSERT_GEQ("socket", socket_fd, CONFIG_NFILE_DESCRIPTORS);
int fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
TC_ASSERT_GEQ("socket", fd, CONFIG_NFILE_DESCRIPTORS);
memset(&sa, 0, sizeof sa);
memset(&saddr, 0, sizeof saddr);
sa.sin_family = AF_INET;
sa.sin_port = htons(ADDR_PORT);
sa.sin_addr.s_addr = htonl(INADDR_ANY);
saddr.sin_family = AF_INET;
saddr.sin_port = htons(SOCK_PORT);
saddr.sin_addr.s_addr = htonl(INADDR_ANY);
int ret = bind(socket_fd, (struct sockaddr *)&sa, sizeof(sa));
TC_ASSERT_EQ_CLEANUP("bind", ret, 0, close(socket_fd); close(fd));
ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
TC_ASSERT_EQ_CLEANUP("bind", ret, 0, close(socket_fd); close(fd));
ret = listen(socket_fd, BACK_LOG);
TC_ASSERT_EQ_CLEANUP("listen", ret, 0, close(socket_fd); close(fd));
ret = listen(fd, BACK_LOG);
TC_ASSERT_EQ_CLEANUP("listen", ret, 0, close(socket_fd); close(fd));
ret = close(socket_fd);
TC_ASSERT_EQ_CLEANUP("close", ret, 0, close(fd));
ret = close(fd);
TC_ASSERT_EQ("close", ret, 0);
TC_SUCCESS_RESULT();
}
static void tc_driver_mtd_procfs_ops(void)
{
int fd;
int ret;
struct stat st;
fd = open(MTD_PROCFS_PATH, O_RDONLY);
TC_ASSERT_GEQ("open", fd, 0);
ret = stat(MTD_PROCFS_PATH, &st);
TC_ASSERT_EQ_CLEANUP("stat", ret, OK, close(fd));
ret = close(fd);
TC_ASSERT_EQ("close", ret, OK);
TC_SUCCESS_RESULT();
}
