bool test_server_create_invalid_argument_4 (Test *test)
{
TITLE ();
CATCH (net_server_create ("127.0.0.1", 8888, &on_connect, NULL, NULL));
CATCH (error_count () != 1);
CATCH (error_at (0).error != ErrorInvalidArgument);
CATCH (error_at (0).code != 4);
PASS ();
}
bool test_server_create_invalid_argument_1 (Test *test)
{
TITLE ();
CATCH (net_server_create (NULL, 0, NULL, NULL, NULL));
CATCH (error_count () != 1);
CATCH (error_at (0).error != ErrorInvalidArgument);
CATCH (error_at (0).code != 1);
PASS ();
}
bool test_server_create (Test *test)
{
NetServer *server;
TITLE ();
CATCH (!(server = net_server_create ("127.0.0.1", 8888, &on_connect, &on_error, NULL)));
CATCH (error_count () != 0);
net_server_destroy (server);
PASS ();
}
bool test_server_create_function_call_1 (Test *test)
{
TITLE ();
memory_commit_limit (sizeof (size_t) + sizeof (NetServer) - 1);
CATCH (net_server_create ("127.0.0.1", 8888, &on_connect, &on_error, NULL));
CATCH (error_count () == 0);
CATCH (error_at (0).error != ErrorFunctionCall);
CATCH (error_at (0).code != 1);
PASS ();
}
net_server *net_server_start(int port) {
int optval = 1, res;
net_file_event *fe = NULL;
struct sockaddr_in addr;
memset(&addr, 0, sizeof(struct sockaddr_in));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons(port);
signal(SIGPIPE, SIG_IGN);
net_server *s = net_server_create();
if(!s) goto err;
s->fd = socket(AF_INET, SOCK_STREAM, 0);
if(s->fd == -1) goto err;
setsockopt(s->fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
res = bind(s->fd, (const struct sockaddr *) &addr, sizeof(struct sockaddr_in));
if(res != 0) goto err;
res = listen(s->fd, NET_SERVER_BACKLOG);
if(res != 0) goto err;
// create epoll instance and add the server fd
int epfd = epoll_create(NET_EPOLL_HINT);
if(epfd == -1) goto err;
s->epfd = epfd;
fe = net_file_event_create((void *) s, net_file_event_type_server);
if(!fe) goto err;
struct epoll_event ee;
memset(&ee, 0, sizeof(struct epoll_event));
ee.events |= EPOLLIN;
ee.data.u64 = 0;
ee.data.ptr = (void *) fe;
res = epoll_ctl(epfd, EPOLL_CTL_ADD, s->fd, &ee);
if(res == -1) goto err;
return s;
err:
log_error("Failed to start server: %s\n", strerror(errno));
if(s) net_server_destroy(s);
if(fe) net_file_event_destroy(fe);
return NULL;
}
bool test_poll_close_2 (Test *test)
{
NetPoll *poll;
NetServer *server;
NetClientConnection connection;
NetClient *client;
TITLE ();
monitor_success = false;
close_success = false;
poll_connection.closed = false;
poll_connection.socket = 0;
poll_connection.tag = NULL;
CATCH (!(server = net_server_create ("127.0.0.1", 8888,
&server_on_connect,
&server_on_error,
NULL)));
CATCH (!(client = net_client_create (&client_on_connect,
&client_on_connect_error,
&client_on_error,
NULL)));
connection.ip = "127.0.0.1";
connection.port = 8888;
net_client_connect (client, &connection);
thread_signal_wait (&server_signal);
CATCH (!(poll = net_poll_create (&on_monitor, &on_close, NULL, NULL)));
poll_connection.socket = server_socket;
CATCH (!net_poll_monitor (poll, &poll_connection));
thread_signal_wait (&monitor_signal);
CATCH (!monitor_success);
CATCH (!net_poll_close (poll, &poll_connection));
thread_signal_wait (&close_signal);
CATCH (!close_success);
net_poll_destroy (poll);
close (server_socket);
close (client_socket);
net_server_destroy (server);
net_client_destroy (client);
CATCH (error_count () != 0);
PASS ();
}
bool test_poll_write_2 (Test *test)
{
NetPoll *poll;
NetServer *server;
NetClient *client;
NetClientConnection connect;
size_t i;
TITLE ();
poll_client.closed = false;
poll_server.closed = false;
read_count = 0;
CATCH (!(server = net_server_create ("127.0.0.1", 8888,
&server_on_connect,
&server_on_error,
NULL)));
CATCH (!(client = net_client_create (&client_on_connect,
&client_on_connect_error,
&client_on_error,
NULL)));
CATCH (!(poll = net_poll_create (&poll_on_monitor,
&poll_on_close,
&poll_on_read,
&poll_on_write)));
// Allocate buffer
CATCH (!(write_buffer = memory_create (BufferSize)));
for (i = 0; i < BufferSize; i++) {
write_buffer[i] = (unsigned char)i;
}
// Connect client.
connect.ip = "127.0.0.1";
connect.port = 8888;
net_client_connect (client, &connect);
// Wait for connections to be completed.
thread_signal_wait (&client_connect_signal);
thread_signal_wait (&server_connect_signal);
// Poll client and server connection.
poll_client.socket = client_socket;
poll_server.socket = server_socket;
CATCH (!net_poll_monitor (poll, &poll_client));
CATCH (!net_poll_monitor (poll, &poll_server));
// Wait for monitors to be completed.
thread_signal_wait (&client_monitor_signal);
thread_signal_wait (&server_monitor_signal);
// Write and wait.
CATCH (!net_poll_write (poll, &poll_server, write_buffer, BufferSize));
thread_signal_wait (&client_read_signal);
// We're done, let's close poll client.
net_poll_close (poll, &poll_client);
// Now wait for client and server poll to close.
thread_signal_wait (&client_close_signal);
thread_signal_wait (&server_close_signal);
net_poll_destroy (poll);
net_server_destroy (server);
net_client_destroy (client);
memory_destroy (write_buffer);
CATCH (error_count () != 0);
PASS ();
}
bool test_write (Test *test)
{
NetServer *server;
NetClient *client;
NetClientConnection connect;
NetStream *stream_server;
NetStream *stream_client;
unsigned char *buffer = (unsigned char *)"x";
size_t i;
TITLE ();
write_count = 2000;
read_count = 0;
CATCH (!(server = net_server_create ("127.0.0.1", 8888,
&server_on_connect,
&server_on_error,
NULL)));
CATCH (!(client = net_client_create (&client_on_connect,
&client_on_connect_error,
&client_on_error,
NULL)));
// Connect client.
connect.ip = "127.0.0.1";
connect.port = 8888;
net_client_connect (client, &connect);
// Wait for connections to be completed.
thread_signal_wait (&client_connect_signal);
thread_signal_wait (&server_connect_signal);
// Create streams.
CATCH (!(stream_server = net_stream_create (&server_stream_on_add,
&server_stream_on_close,
&server_stream_on_read,
NULL)));
CATCH (!(stream_client = net_stream_create (&client_stream_on_add,
&client_stream_on_close,
NULL,
NULL)));
// Add sockets to streams.
CATCH (!net_stream_add (stream_server, server_socket));
CATCH (!net_stream_add (stream_client, client_socket));
// Wait for add to be completed.
thread_signal_wait (&client_add_signal);
thread_signal_wait (&server_add_signal);
// Write 2000 times.
for (i = 0; i < write_count; i++) {
CATCH (!net_stream_write (stream_client,
stream_connection_client,
buffer,
1));
}
thread_signal_wait (&server_read_signal);
// Close client connection, should cause server to close as well.
net_stream_close (stream_client, stream_connection_client);
// Wait for close to be completed.
thread_signal_wait (&client_close_signal);
thread_signal_wait (&server_close_signal);
// Remove closed streams.
net_stream_remove (stream_server, stream_connection_server);
net_stream_remove (stream_client, stream_connection_client);
// We're done, let's destroy streams.
net_stream_destroy (stream_server);
net_stream_destroy (stream_client);
net_server_destroy (server);
net_client_destroy (client);
CATCH (error_count () != 0);
PASS ();
}
