bool test_websocket_connect_error (Test *test)
{
NetWebsocket *websocket;
NetClientConnection connection;
NetClient *client;
TITLE ();
CATCH (!(websocket = net_websocket_create (&on_add,
&on_close,
&on_request)));
websocket->test.ConnectError = true;
// Connect with client.
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);
CATCH (!thread_signal_wait (&client_ready));
net_client_destroy (client);
net_websocket_destroy (websocket);
CATCH (error_at (0).error != ErrorFunctionCall);
CATCH (!string_equals (error_at (0).function, "server_on_connect"));
PASS ();
}
void client_start (size_t count, size_t _package_size, size_t _seconds)
{
connections_max = count;
package_size = _package_size;
seconds = _seconds;
buffer = memory_create (sizeof (char) * package_size);
connections = memory_create (sizeof (NetClientConnection) * count);
streams = memory_create (sizeof (NetStreamConnection *) * count);
stream = net_stream_create (&client_stream_on_add,
&client_stream_on_close,
&client_stream_on_read,
NULL);
client = net_client_create (&client_on_connect,
&client_on_connect_error,
&client_on_error,
NULL);
(void)thread_create (&worker, NULL);
}
static net_client *net_server_accept(net_server *s) {
struct sockaddr_in addr;
socklen_t addrlen = sizeof(struct sockaddr_in);
int fd;
net_client *c = NULL;
net_file_event *fe = NULL;
if((fd = accept(s->fd, (struct sockaddr *) &addr, &addrlen)) == -1)
goto err;
if(fcntl(fd, F_SETFL, O_NONBLOCK) != 0)
goto err;
if((c = net_client_create(fd, addr)) == NULL)
goto err;
if((fe = net_file_event_create((void *) c, net_file_event_type_client)) == NULL)
goto err;
struct epoll_event ee;
memset(&ee, 0, sizeof(struct epoll_event));
ee.events |= EPOLLIN;
ee.events |= EPOLLOUT;
ee.data.u64 = 0;
ee.data.ptr = (void *) fe;
if(epoll_ctl(s->epfd, EPOLL_CTL_ADD, fd, &ee) != 0)
goto err;
return c;
err:
if(c)
net_client_close(s, c);
else if(fd)
close(fd);
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 ();
}
