forked from acouzens/open5gs
678 lines
18 KiB
C
678 lines
18 KiB
C
/*
|
|
* Copyright (C) 2019 by Sukchan Lee <acetcom@gmail.com>
|
|
*
|
|
* This file is part of Open5GS.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "ogs-core.h"
|
|
#include "core/abts.h"
|
|
|
|
#define DATASTR "This is a test"
|
|
#define STRLEN 8092
|
|
#define PORT 47777
|
|
#define NUM 100
|
|
|
|
#ifndef AI_PASSIVE
|
|
#define AI_PASSIVE 1
|
|
#endif
|
|
|
|
#if 0 /* FIXME : Not working in WIN32, i585 */
|
|
static int test1_called = 0;
|
|
|
|
static void test1_handler(short when, ogs_socket_t fd, void *data)
|
|
{
|
|
abts_case *tc = data;
|
|
char str[STRLEN];
|
|
ssize_t size;
|
|
|
|
ABTS_INT_EQUAL(tc, OGS_POLLIN, when);
|
|
|
|
size = ogs_recv(fd, str, STRLEN, 0);
|
|
ABTS_INT_EQUAL(tc, strlen(DATASTR), size);
|
|
|
|
test1_called++;
|
|
}
|
|
|
|
static void test1_func(abts_case *tc, void *data)
|
|
{
|
|
int rv;
|
|
int i;
|
|
ssize_t size;
|
|
ogs_poll_t *poll[NUM];
|
|
ogs_sockaddr_t *addr;
|
|
ogs_socknode_t *server[NUM], *client[NUM];
|
|
ogs_pollset_t *pollset = ogs_pollset_create(512);
|
|
ABTS_PTR_NOTNULL(tc, pollset);
|
|
|
|
for (i = 0; i < NUM; i++) {
|
|
rv = ogs_getaddrinfo(&addr, AF_INET, "127.0.0.1", PORT+i, AI_PASSIVE);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
server[i] = ogs_socknode_new(addr);
|
|
ABTS_PTR_NOTNULL(tc, server[i]);
|
|
server[i]->sock = ogs_udp_server(server[i]->addr, NULL);
|
|
ABTS_PTR_NOTNULL(tc, server[i]->sock);
|
|
rv = ogs_getaddrinfo(&addr, AF_INET, "127.0.0.1", PORT+i, AI_PASSIVE);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
client[i] = ogs_socknode_new(addr);
|
|
ABTS_PTR_NOTNULL(tc, client[i]);
|
|
client[i]->sock = ogs_udp_client(client[i]->addr, NULL);
|
|
ABTS_PTR_NOTNULL(tc, client[i]->sock);
|
|
}
|
|
|
|
for (i = 0; i < NUM; i+=2) {
|
|
poll[i] = ogs_pollset_add(pollset, OGS_POLLIN,
|
|
server[i]->sock->fd, test1_handler, tc);
|
|
ABTS_PTR_NOTNULL(tc, poll);
|
|
|
|
size = ogs_send(client[i]->sock->fd, DATASTR, strlen(DATASTR), 0);
|
|
ABTS_INT_EQUAL(tc, strlen(DATASTR), size);
|
|
}
|
|
|
|
test1_called = 0;
|
|
rv = ogs_pollset_poll(pollset, OGS_INFINITE_TIME);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
ABTS_INT_EQUAL(tc, NUM/2, test1_called);
|
|
|
|
for (i = 1; i < NUM; i+=2) {
|
|
poll[i] = ogs_pollset_add(pollset, OGS_POLLIN,
|
|
server[i]->sock->fd, test1_handler, tc);
|
|
ABTS_PTR_NOTNULL(tc, poll);
|
|
}
|
|
|
|
for (i = 0; i < NUM; i++) {
|
|
size = ogs_send(client[i]->sock->fd, DATASTR, strlen(DATASTR), 0);
|
|
ABTS_INT_EQUAL(tc, strlen(DATASTR), size);
|
|
}
|
|
|
|
test1_called = 0;
|
|
rv = ogs_pollset_poll(pollset, OGS_INFINITE_TIME);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
ABTS_INT_EQUAL(tc, NUM, test1_called);
|
|
|
|
for (i = 0; i < NUM; i+=2) {
|
|
ogs_pollset_remove(poll[i]);
|
|
}
|
|
|
|
for (i = 1; i < NUM; i+=2) {
|
|
size = ogs_send(client[i]->sock->fd, DATASTR, strlen(DATASTR), 0);
|
|
ABTS_INT_EQUAL(tc, strlen(DATASTR), size);
|
|
}
|
|
|
|
test1_called = 0;
|
|
rv = ogs_pollset_poll(pollset, OGS_INFINITE_TIME);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
ABTS_INT_EQUAL(tc, NUM/2, test1_called);
|
|
|
|
for (i = 1; i < NUM; i+=2) {
|
|
ogs_pollset_remove(poll[i]);
|
|
}
|
|
|
|
rv = ogs_pollset_poll(pollset, ogs_time_from_msec(100));
|
|
ABTS_INT_EQUAL(tc, OGS_TIMEUP, rv);
|
|
|
|
for (i = 0; i < NUM; i++) {
|
|
ogs_socknode_free(client[i]);
|
|
ogs_socknode_free(server[i]);
|
|
}
|
|
|
|
ogs_pollset_destroy(pollset);
|
|
}
|
|
#endif
|
|
|
|
static ogs_sock_t *test2_client;
|
|
static int test2_okay = 1;
|
|
|
|
static void test2_handler(short when, ogs_socket_t fd, void *data)
|
|
{
|
|
abts_case *tc = data;
|
|
const char *test = "test string";
|
|
int len;
|
|
|
|
ABTS_INT_EQUAL(tc, OGS_POLLOUT, when);
|
|
|
|
len = ogs_send(fd, test, (int)strlen(test) + 1, 0);
|
|
|
|
if (len > 0) {
|
|
ogs_sock_destroy(test2_client);
|
|
}
|
|
|
|
test2_okay = 0;
|
|
}
|
|
|
|
static void test2_func(abts_case *tc, void *data)
|
|
{
|
|
int rv;
|
|
ogs_poll_t *poll;
|
|
ogs_sock_t *server, *client, *accept;
|
|
ogs_sockaddr_t *addr;
|
|
ogs_pollset_t *pollset = ogs_pollset_create(512);
|
|
ABTS_PTR_NOTNULL(tc, pollset);
|
|
|
|
rv = ogs_getaddrinfo(&addr, AF_INET, "127.0.0.1", PORT, AI_PASSIVE);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
server = ogs_tcp_server(addr, NULL);
|
|
ABTS_PTR_NOTNULL(tc, server);
|
|
rv = ogs_freeaddrinfo(addr);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
rv = ogs_getaddrinfo(&addr, AF_INET, "127.0.0.1", PORT, AI_PASSIVE);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
test2_client = ogs_tcp_client(addr, NULL);
|
|
ABTS_PTR_NOTNULL(tc, test2_client);
|
|
rv = ogs_freeaddrinfo(addr);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
accept = ogs_sock_accept(server);
|
|
ABTS_PTR_NOTNULL(tc, accept);
|
|
|
|
poll = ogs_pollset_add(pollset, OGS_POLLOUT,
|
|
accept->fd, test2_handler, tc);
|
|
ABTS_PTR_NOTNULL(tc, poll);
|
|
|
|
rv = ogs_pollset_poll(pollset, OGS_INFINITE_TIME);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
ABTS_INT_EQUAL(tc, 0, test2_okay);
|
|
|
|
ogs_pollset_remove(poll);
|
|
|
|
ogs_sock_destroy(accept);
|
|
ogs_sock_destroy(server);
|
|
|
|
ogs_pollset_destroy(pollset);
|
|
}
|
|
|
|
static ogs_socket_t test3_fd[2];
|
|
static int test3_okay = 1;
|
|
|
|
static void test3_handler(short when, ogs_socket_t fd, void *data)
|
|
{
|
|
abts_case *tc = data;
|
|
const char *test = "test string";
|
|
int len;
|
|
|
|
ABTS_INT_EQUAL(tc, OGS_POLLOUT, when);
|
|
|
|
len = ogs_send(fd, test, (int)strlen(test) + 1, 0);
|
|
|
|
if (len > 0) {
|
|
ogs_closesocket(test3_fd[0]);
|
|
}
|
|
test3_okay = 0;
|
|
}
|
|
|
|
static void test3_func(abts_case *tc, void *data)
|
|
{
|
|
int rv;
|
|
ogs_poll_t *poll = NULL;
|
|
ogs_pollset_t *pollset = ogs_pollset_create(512);
|
|
ABTS_PTR_NOTNULL(tc, pollset);
|
|
|
|
rv = ogs_socketpair(AF_SOCKPAIR, SOCK_STREAM, 0, test3_fd);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
poll = ogs_pollset_add(pollset, OGS_POLLOUT,
|
|
test3_fd[1], test3_handler, tc);
|
|
ABTS_PTR_NOTNULL(tc, poll);
|
|
|
|
rv = ogs_pollset_poll(pollset, OGS_INFINITE_TIME);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
ogs_pollset_remove(poll);
|
|
|
|
ABTS_INT_EQUAL(tc, 0, test3_okay);
|
|
|
|
ogs_closesocket(test3_fd[1]);
|
|
|
|
ogs_pollset_destroy(pollset);
|
|
}
|
|
|
|
static ogs_thread_t *test4_thread;
|
|
static void test4_main(void *data)
|
|
{
|
|
abts_case *tc = data;
|
|
int rv;
|
|
ogs_sock_t *udp;
|
|
ogs_sockaddr_t *sa;
|
|
ssize_t size;
|
|
|
|
udp = ogs_sock_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
|
|
ABTS_PTR_NOTNULL(tc, udp);
|
|
|
|
rv = ogs_getaddrinfo(&sa, AF_INET, NULL, PORT, 0);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
size = ogs_sendto(udp->fd, DATASTR, strlen(DATASTR), 0, sa);
|
|
ABTS_INT_EQUAL(tc, strlen(DATASTR), size);
|
|
|
|
rv = ogs_freeaddrinfo(sa);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
ogs_sock_destroy(udp);
|
|
}
|
|
|
|
static void test4_handler(short when, ogs_socket_t fd, void *data)
|
|
{
|
|
abts_case *tc = data;
|
|
ssize_t size;
|
|
char str[STRLEN];
|
|
ogs_sockaddr_t sa;
|
|
char buf[OGS_ADDRSTRLEN];
|
|
|
|
ABTS_INT_EQUAL(tc, OGS_POLLIN, when);
|
|
|
|
size = ogs_recvfrom(fd, str, STRLEN, 0, &sa);
|
|
ABTS_INT_EQUAL(tc, strlen(DATASTR), size);
|
|
ABTS_STR_EQUAL(tc, "127.0.0.1", OGS_ADDR(&sa, buf));
|
|
}
|
|
|
|
static void test4_func(abts_case *tc, void *data)
|
|
{
|
|
int rv;
|
|
ogs_sock_t *udp;
|
|
ogs_sockaddr_t *addr;
|
|
ogs_socknode_t *node;
|
|
ogs_poll_t *poll;
|
|
ogs_pollset_t *pollset = ogs_pollset_create(512);
|
|
ABTS_PTR_NOTNULL(tc, pollset);
|
|
|
|
rv = ogs_getaddrinfo(&addr, AF_INET, NULL, PORT, AI_PASSIVE);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
udp = ogs_udp_server(addr, NULL);
|
|
ABTS_PTR_NOTNULL(tc, udp);
|
|
poll = ogs_pollset_add(pollset, OGS_POLLIN, udp->fd, test4_handler, tc);
|
|
|
|
test4_thread = ogs_thread_create(test4_main, tc);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
rv = ogs_pollset_poll(pollset, OGS_INFINITE_TIME);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
ogs_thread_destroy(test4_thread);
|
|
|
|
ogs_pollset_remove(poll);
|
|
|
|
ogs_sock_destroy(udp);
|
|
|
|
rv = ogs_freeaddrinfo(addr);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
ogs_pollset_destroy(pollset);
|
|
}
|
|
|
|
static void test5_func(abts_case *tc, void *data)
|
|
{
|
|
int rv;
|
|
ogs_pollset_t *pollset = ogs_pollset_create(512);
|
|
ABTS_PTR_NOTNULL(tc, pollset);
|
|
|
|
rv = ogs_pollset_poll(pollset, ogs_time_from_msec(100));
|
|
ABTS_INT_EQUAL(tc, OGS_TIMEUP, rv);
|
|
rv = ogs_pollset_notify(pollset);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
rv = ogs_pollset_poll(pollset, ogs_time_from_msec(100));
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
rv = ogs_pollset_poll(pollset, ogs_time_from_msec(100));
|
|
ABTS_INT_EQUAL(tc, OGS_TIMEUP, rv);
|
|
rv = ogs_pollset_notify(pollset);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
rv = ogs_pollset_notify(pollset);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
rv = ogs_pollset_notify(pollset);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
rv = ogs_pollset_poll(pollset, ogs_time_from_msec(100));
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
rv = ogs_pollset_poll(pollset, ogs_time_from_msec(100));
|
|
ABTS_INT_EQUAL(tc, OGS_TIMEUP, rv);
|
|
|
|
ogs_pollset_destroy(pollset);
|
|
}
|
|
|
|
static int test6_okay = 1;
|
|
static void test6_handler(short when, ogs_socket_t fd, void *data)
|
|
{
|
|
abts_case *tc = data;
|
|
|
|
ABTS_TRUE(tc, (when & OGS_POLLIN));
|
|
test6_okay = 0;
|
|
}
|
|
|
|
static void test6_func(abts_case *tc, void *data)
|
|
{
|
|
int rv;
|
|
ogs_socket_t fd[2];
|
|
ogs_poll_t *poll = NULL;
|
|
ogs_pollset_t *pollset = ogs_pollset_create(512);
|
|
ABTS_PTR_NOTNULL(tc, pollset);
|
|
|
|
rv = ogs_socketpair(AF_SOCKPAIR, SOCK_STREAM, 0, fd);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
poll = ogs_pollset_add(pollset, OGS_POLLIN, fd[1], test6_handler, tc);
|
|
ABTS_PTR_NOTNULL(tc, poll);
|
|
|
|
ogs_closesocket(fd[0]);
|
|
|
|
rv = ogs_pollset_poll(pollset, OGS_INFINITE_TIME);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
ABTS_INT_EQUAL(tc, 0, test6_okay);
|
|
|
|
ogs_pollset_remove(poll);
|
|
|
|
ogs_closesocket(fd[1]);
|
|
|
|
ogs_pollset_destroy(pollset);
|
|
}
|
|
|
|
/*
|
|
static void test7_io_handler(ogs_poll_t *poll)
|
|
{
|
|
ogs_poll_t *poll = NULL;
|
|
|
|
poll = mme_poll_new(pollset, addr, ipv6);
|
|
ogs_assert(poll);
|
|
|
|
ogs_poll_queue_push(poll);
|
|
}
|
|
|
|
static void test7_queue_handler(ogs_poll_t *poll)
|
|
{
|
|
}
|
|
|
|
static void test7_queue_handler(ogs_poll_t *poll)
|
|
{
|
|
mme_poll_data_t *data = _data;
|
|
ogs_assert(data);
|
|
|
|
mme_poll_free(poll);
|
|
}
|
|
*/
|
|
|
|
static void test7_func(abts_case *tc, void *data)
|
|
{
|
|
/*
|
|
int rv;
|
|
ogs_pollset_t *pollset = ogs_pollset_create(512);
|
|
|
|
ogs_poll_t *poll = NULL;
|
|
poll = ogs_poll_new(pollset, test7_handler, tc);
|
|
|
|
rv = ogs_socketpair(AF_SOCKPAIR, SOCK_STREAM, 0, fd);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
ogs_poll_io_register(poll, OGS_POLLIN, fd[0]);
|
|
ogs_poll_io_unregister(poll);
|
|
|
|
ogs_closesocket(fd[0]);
|
|
ogs_closesocket(fd[1]);
|
|
|
|
ogs_poll_free(poll);
|
|
|
|
ogs_poll_t *poll = NULL;
|
|
|
|
poll = mme_poll_new(pollset, test7_queue_handler, addr, ipv6);
|
|
ogs_assert(poll);
|
|
|
|
ogs_poll_queue_push(poll);
|
|
|
|
ogs_poll_t *poll = NULL;
|
|
|
|
poll = ogs_poll_timer_create(pollset, test7_handler, TIMER_ID);
|
|
ogs_poll_timer_start(poll);
|
|
|
|
ogs_pollset_destroy(pollset);
|
|
*/
|
|
}
|
|
|
|
static ogs_socknode_t *test8_server;
|
|
static ogs_socknode_t *test8_client1, *test8_client2, *test8_client3;
|
|
static ogs_sock_t *test8_accept1, *test8_accept2, *test8_accept3;
|
|
static int test8_okay = 1;
|
|
|
|
static void test8_handler(short when, ogs_socket_t fd, void *data)
|
|
{
|
|
test8_okay++;
|
|
}
|
|
|
|
static void test8_handler_with_remove(short when, ogs_socket_t fd, void *data)
|
|
{
|
|
ogs_poll_t *poll = data;
|
|
|
|
ogs_assert(when == OGS_POLLOUT);
|
|
ogs_assert(poll);
|
|
ogs_pollset_remove(poll);
|
|
|
|
test8_okay++;
|
|
}
|
|
|
|
static void test8_func(abts_case *tc, void *data)
|
|
{
|
|
int rv;
|
|
ogs_poll_t *write1, *write2, *write3;
|
|
ogs_sock_t *server, *client1, *client2, *client3;
|
|
ogs_sock_t *accept1, *accept2, *accept3;
|
|
ogs_sockaddr_t *addr;
|
|
ogs_pollset_t *pollset = ogs_pollset_create(512);
|
|
ABTS_PTR_NOTNULL(tc, pollset);
|
|
|
|
rv = ogs_getaddrinfo(&addr, AF_INET, "127.0.0.1", PORT, AI_PASSIVE);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
server = ogs_tcp_server(addr, NULL);
|
|
ABTS_PTR_NOTNULL(tc, server);
|
|
rv = ogs_freeaddrinfo(addr);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
rv = ogs_getaddrinfo(&addr, AF_INET, "127.0.0.1", PORT, AI_PASSIVE);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
client1 = ogs_tcp_client(addr, NULL);
|
|
ABTS_PTR_NOTNULL(tc, client1);
|
|
rv = ogs_freeaddrinfo(addr);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
accept1 = ogs_sock_accept(server);
|
|
ABTS_PTR_NOTNULL(tc, accept1);
|
|
|
|
rv = ogs_getaddrinfo(&addr, AF_INET, "127.0.0.1", PORT, AI_PASSIVE);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
client2 = ogs_tcp_client(addr, NULL);
|
|
ABTS_PTR_NOTNULL(tc, client2);
|
|
rv = ogs_freeaddrinfo(addr);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
accept2 = ogs_sock_accept(server);
|
|
ABTS_PTR_NOTNULL(tc, accept2);
|
|
|
|
rv = ogs_getaddrinfo(&addr, AF_INET, "127.0.0.1", PORT, AI_PASSIVE);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
client3 = ogs_tcp_client(addr, NULL);
|
|
ABTS_PTR_NOTNULL(tc, client3);
|
|
rv = ogs_freeaddrinfo(addr);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
accept3 = ogs_sock_accept(server);
|
|
ABTS_PTR_NOTNULL(tc, accept3);
|
|
|
|
write1 = ogs_pollset_add(pollset, OGS_POLLOUT,
|
|
accept1->fd, test8_handler, NULL);
|
|
ABTS_PTR_NOTNULL(tc, write1);
|
|
|
|
write2 = ogs_pollset_add(pollset, OGS_POLLOUT,
|
|
accept2->fd, test8_handler, NULL);
|
|
ABTS_PTR_NOTNULL(tc, write2);
|
|
|
|
write3 = ogs_pollset_add(pollset, OGS_POLLOUT,
|
|
accept3->fd, test8_handler, NULL);
|
|
ABTS_PTR_NOTNULL(tc, write3);
|
|
|
|
rv = ogs_pollset_poll(pollset, OGS_INFINITE_TIME);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
ABTS_INT_EQUAL(tc, 4, test8_okay);
|
|
|
|
ogs_pollset_remove(write1);
|
|
ogs_pollset_remove(write2);
|
|
ogs_pollset_remove(write3);
|
|
|
|
write2 = ogs_pollset_add(pollset, OGS_POLLOUT,
|
|
accept2->fd, test8_handler, NULL);
|
|
ABTS_PTR_NOTNULL(tc, write2);
|
|
|
|
write3 = ogs_pollset_add(pollset, OGS_POLLOUT,
|
|
accept3->fd, test8_handler, NULL);
|
|
ABTS_PTR_NOTNULL(tc, write3);
|
|
|
|
rv = ogs_pollset_poll(pollset, OGS_INFINITE_TIME);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
ABTS_INT_EQUAL(tc, 6, test8_okay);
|
|
|
|
ogs_pollset_remove(write2);
|
|
ogs_pollset_remove(write3);
|
|
|
|
write3 = ogs_pollset_add(pollset, OGS_POLLOUT,
|
|
accept3->fd, test8_handler, NULL);
|
|
ABTS_PTR_NOTNULL(tc, write3);
|
|
|
|
rv = ogs_pollset_poll(pollset, OGS_INFINITE_TIME);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
ABTS_INT_EQUAL(tc, 7, test8_okay);
|
|
|
|
ogs_pollset_remove(write3);
|
|
|
|
write1 = ogs_pollset_add(pollset, OGS_POLLOUT,
|
|
accept1->fd, test8_handler_with_remove,
|
|
ogs_pollset_self_handler_data());
|
|
ABTS_PTR_NOTNULL(tc, write1);
|
|
|
|
write2 = ogs_pollset_add(pollset, OGS_POLLOUT,
|
|
accept2->fd, test8_handler_with_remove,
|
|
ogs_pollset_self_handler_data());
|
|
ABTS_PTR_NOTNULL(tc, write2);
|
|
|
|
write3 = ogs_pollset_add(pollset, OGS_POLLOUT,
|
|
accept3->fd, test8_handler_with_remove,
|
|
ogs_pollset_self_handler_data());
|
|
ABTS_PTR_NOTNULL(tc, write3);
|
|
|
|
rv = ogs_pollset_poll(pollset, OGS_INFINITE_TIME);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
ABTS_INT_EQUAL(tc, 10, test8_okay);
|
|
|
|
write1 = ogs_pollset_add(pollset, OGS_POLLOUT,
|
|
accept1->fd, test8_handler_with_remove,
|
|
ogs_pollset_self_handler_data());
|
|
ABTS_PTR_NOTNULL(tc, write1);
|
|
|
|
write2 = ogs_pollset_add(pollset, OGS_POLLOUT,
|
|
accept2->fd, test8_handler_with_remove,
|
|
ogs_pollset_self_handler_data());
|
|
ABTS_PTR_NOTNULL(tc, write2);
|
|
|
|
rv = ogs_pollset_poll(pollset, OGS_INFINITE_TIME);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
ABTS_INT_EQUAL(tc, 12, test8_okay);
|
|
|
|
write1 = ogs_pollset_add(pollset, OGS_POLLOUT,
|
|
accept1->fd, test8_handler_with_remove,
|
|
ogs_pollset_self_handler_data());
|
|
ABTS_PTR_NOTNULL(tc, write1);
|
|
|
|
rv = ogs_pollset_poll(pollset, OGS_INFINITE_TIME);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
ABTS_INT_EQUAL(tc, 13, test8_okay);
|
|
|
|
write1 = ogs_pollset_add(pollset, OGS_POLLIN|OGS_POLLOUT,
|
|
accept1->fd, test8_handler_with_remove,
|
|
ogs_pollset_self_handler_data());
|
|
ABTS_PTR_NOTNULL(tc, write1);
|
|
|
|
write2 = ogs_pollset_add(pollset, OGS_POLLIN|OGS_POLLOUT,
|
|
accept2->fd, test8_handler_with_remove,
|
|
ogs_pollset_self_handler_data());
|
|
ABTS_PTR_NOTNULL(tc, write2);
|
|
|
|
write3 = ogs_pollset_add(pollset, OGS_POLLIN|OGS_POLLOUT,
|
|
accept3->fd, test8_handler_with_remove,
|
|
ogs_pollset_self_handler_data());
|
|
ABTS_PTR_NOTNULL(tc, write3);
|
|
|
|
rv = ogs_pollset_poll(pollset, OGS_INFINITE_TIME);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
ABTS_INT_EQUAL(tc, 16, test8_okay);
|
|
|
|
write2 = ogs_pollset_add(pollset, OGS_POLLIN|OGS_POLLOUT,
|
|
accept2->fd, test8_handler_with_remove,
|
|
ogs_pollset_self_handler_data());
|
|
ABTS_PTR_NOTNULL(tc, write2);
|
|
|
|
write3 = ogs_pollset_add(pollset, OGS_POLLIN|OGS_POLLOUT,
|
|
accept3->fd, test8_handler_with_remove,
|
|
ogs_pollset_self_handler_data());
|
|
ABTS_PTR_NOTNULL(tc, write3);
|
|
|
|
rv = ogs_pollset_poll(pollset, OGS_INFINITE_TIME);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
ABTS_INT_EQUAL(tc, 18, test8_okay);
|
|
|
|
write3 = ogs_pollset_add(pollset, OGS_POLLIN|OGS_POLLOUT,
|
|
accept3->fd, test8_handler_with_remove,
|
|
ogs_pollset_self_handler_data());
|
|
ABTS_PTR_NOTNULL(tc, write3);
|
|
|
|
rv = ogs_pollset_poll(pollset, OGS_INFINITE_TIME);
|
|
ABTS_INT_EQUAL(tc, OGS_OK, rv);
|
|
|
|
ABTS_INT_EQUAL(tc, 19, test8_okay);
|
|
|
|
ogs_sock_destroy(client1);
|
|
ogs_sock_destroy(accept1);
|
|
|
|
ogs_sock_destroy(client2);
|
|
ogs_sock_destroy(accept2);
|
|
|
|
ogs_sock_destroy(client3);
|
|
ogs_sock_destroy(accept3);
|
|
|
|
ogs_sock_destroy(server);
|
|
|
|
ogs_pollset_destroy(pollset);
|
|
}
|
|
|
|
abts_suite *test_poll(abts_suite *suite)
|
|
{
|
|
suite = ADD_SUITE(suite)
|
|
|
|
#if 0 /* FIXME : Not working in WIN32, i585 */
|
|
abts_run_test(suite, test1_func, NULL);
|
|
#endif
|
|
|
|
abts_run_test(suite, test2_func, NULL);
|
|
abts_run_test(suite, test3_func, NULL);
|
|
abts_run_test(suite, test4_func, NULL);
|
|
abts_run_test(suite, test5_func, NULL);
|
|
abts_run_test(suite, test6_func, NULL);
|
|
abts_run_test(suite, test7_func, NULL);
|
|
abts_run_test(suite, test8_func, NULL);
|
|
|
|
return suite;
|
|
}
|