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(); }