void drop_test()
{
INFO_PRINT << "POL datafile drop tests:\n";
// first things first. Gotta be able to drop stuff by the brit bank.
test_drop( 1432, 1696, 0, 1433, 1696, 0, true, 0 );
// in the bank, on the floor
test_drop( 1437, 1687, 0, 1437, 1688, 0, true, 0 );
// on a desk in LB's castle
test_drop( 1328, 1645, 72, 1328, 1644, 78, true, 78 );
// one of these screwy undermap caves
test_drop( 2564, 489, 0, 2564, 489, 0, true, 0 );
test_drop( 2564, 489, 42, 2564, 489, 42, false, 0 );
// a liche room
test_drop( 5310, 735, 0, 5310, 735, 0, true, 0 );
// a downward slope
test_drop( 5304, 2488, 39, 5304, 2489, 35, true, 35 );
// a ramp in an orc fort
test_drop( 5210, 3616, 0, 5210, 3615, 5, true, 2 );
}
/* test_text() verifies that we drop messages properly when sending invalid
UTF-8, but not when we send valid data. */
void test_text ()
{
int sb;
int sc;
int opt;
uint8_t bad[20];
/* Negative testing... bad UTF-8 data for text. */
sb = test_socket (AF_SP, NN_PAIR);
sc = test_socket (AF_SP, NN_PAIR);
opt = NN_WS_MSG_TYPE_TEXT;
test_setsockopt (sb, NN_WS, NN_WS_MSG_TYPE, &opt, sizeof (opt));
opt = NN_WS_MSG_TYPE_TEXT;
test_setsockopt (sc, NN_WS, NN_WS_MSG_TYPE, &opt, sizeof (opt));
opt = 500;
test_setsockopt (sb, NN_SOL_SOCKET, NN_RCVTIMEO, &opt, sizeof (opt));
test_bind (sb, socket_address);
test_connect (sc, socket_address);
test_send (sc, "GOOD");
test_recv (sb, "GOOD");
/* and the bad ... */
strcpy ((char *)bad, "BAD.");
bad[2] = (char)0xDD;
test_send (sc, (char *)bad);
/* Make sure we dropped the frame. */
test_drop (sb, ETIMEDOUT);
test_close (sb);
test_close (sc);
return;
}
int main ()
{
int enda;
int endb;
int endc;
int endd;
int ende1;
int ende2;
struct nn_thread thread1;
struct nn_thread thread2;
struct nn_thread thread3;
int timeo;
/* Test the bi-directional device. */
/* Start the device. */
nn_thread_init (&thread1, device1, NULL);
/* Create two sockets to connect to the device. */
enda = test_socket (AF_SP, NN_PAIR);
test_connect (enda, SOCKET_ADDRESS_A);
endb = test_socket (AF_SP, NN_PAIR);
test_connect (endb, SOCKET_ADDRESS_B);
/* Pass a pair of messages between endpoints. */
test_send (enda, "ABC");
test_recv (endb, "ABC");
test_send (endb, "ABC");
test_recv (enda, "ABC");
/* Clean up. */
test_close (endb);
test_close (enda);
/* Test the uni-directional device. */
/* Start the device. */
nn_thread_init (&thread2, device2, NULL);
/* Create two sockets to connect to the device. */
endc = test_socket (AF_SP, NN_PUSH);
test_connect (endc, SOCKET_ADDRESS_C);
endd = test_socket (AF_SP, NN_PULL);
test_connect (endd, SOCKET_ADDRESS_D);
/* Pass a message between endpoints. */
test_send (endc, "XYZ");
test_recv (endd, "XYZ");
/* Clean up. */
test_close (endd);
test_close (endc);
/* Test the loopback device. */
/* Start the device. */
nn_thread_init (&thread3, device3, NULL);
/* Create two sockets to connect to the device. */
ende1 = test_socket (AF_SP, NN_BUS);
test_connect (ende1, SOCKET_ADDRESS_E);
ende2 = test_socket (AF_SP, NN_BUS);
test_connect (ende2, SOCKET_ADDRESS_E);
/* BUS is unreliable so wait a bit for connections to be established. */
nn_sleep (100);
/* Pass a message to the bus. */
test_send (ende1, "KLM");
test_recv (ende2, "KLM");
/* Make sure that the message doesn't arrive at the socket it was
originally sent to. */
timeo = 100;
test_setsockopt (ende1, NN_SOL_SOCKET, NN_RCVTIMEO,
&timeo, sizeof (timeo));
test_drop (ende1, ETIMEDOUT);
/* Clean up. */
test_close (ende2);
test_close (ende1);
/* Shut down the devices. */
nn_term ();
nn_thread_term (&thread1);
nn_thread_term (&thread2);
nn_thread_term (&thread3);
return 0;
}
int main (int argc, const char *argv[])
{
int rc;
int sb;
int sc;
int sb2;
int opt;
size_t sz;
int i;
char any_address[128];
test_addr_from (socket_address, "ws", "127.0.0.1",
get_test_port (argc, argv));
test_addr_from (any_address, "ws", "*",
get_test_port (argc, argv));
/* Try closing bound but unconnected socket. */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, any_address);
test_close (sb);
/* Try closing a TCP socket while it not connected. At the same time
test specifying the local address for the connection. */
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, socket_address);
test_close (sc);
/* Open the socket anew. */
sc = test_socket (AF_SP, NN_PAIR);
/* Check socket options. */
sz = sizeof (opt);
rc = nn_getsockopt (sc, NN_WS, NN_WS_MSG_TYPE, &opt, &sz);
errno_assert (rc == 0);
nn_assert (sz == sizeof (opt));
nn_assert (opt == NN_WS_MSG_TYPE_BINARY);
/* Default port 80 should be assumed if not explicitly declared. */
rc = nn_connect (sc, "ws://127.0.0.1");
errno_assert (rc >= 0);
/* Try using invalid address strings. */
rc = nn_connect (sc, "ws://*:");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "ws://*:1000000");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "ws://*:some_port");
nn_assert (rc < 0);
rc = nn_connect (sc, "ws://eth10000;127.0.0.1:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == ENODEV);
rc = nn_bind (sc, "ws://127.0.0.1:");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_bind (sc, "ws://127.0.0.1:1000000");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_bind (sc, "ws://eth10000:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == ENODEV);
rc = nn_connect (sc, "ws://:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "ws://-hostname:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "ws://abc.123.---.#:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "ws://[::1]:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "ws://abc.123.:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "ws://abc...123:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "ws://.123:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
test_close (sc);
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, socket_address);
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, socket_address);
/* Ping-pong test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "ABC");
test_recv (sb, "ABC");
test_send (sb, "DEF");
test_recv (sc, "DEF");
}
/* Batch transfer test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "0123456789012345678901234567890123456789");
}
for (i = 0; i != 100; ++i) {
test_recv (sb, "0123456789012345678901234567890123456789");
}
test_close (sc);
test_close (sb);
/* Test two sockets binding to the same address. */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, socket_address);
sb2 = test_socket (AF_SP, NN_PAIR);
rc = nn_bind (sb2, socket_address);
nn_assert (rc < 0);
errno_assert (nn_errno () == EADDRINUSE);
test_close(sb);
test_close(sb2);
/* Test that NN_RCVMAXSIZE can be -1, but not lower */
sb = test_socket (AF_SP, NN_PAIR);
opt = -1;
rc = nn_setsockopt (sb, NN_SOL_SOCKET, NN_RCVMAXSIZE, &opt, sizeof (opt));
nn_assert (rc >= 0);
opt = -2;
rc = nn_setsockopt (sb, NN_SOL_SOCKET, NN_RCVMAXSIZE, &opt, sizeof (opt));
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
test_close (sb);
/* Test NN_RCVMAXSIZE limit */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, socket_address);
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, socket_address);
opt = 1000;
test_setsockopt (sc, NN_SOL_SOCKET, NN_SNDTIMEO, &opt, sizeof (opt));
nn_assert (opt == 1000);
opt = 1000;
test_setsockopt (sb, NN_SOL_SOCKET, NN_RCVTIMEO, &opt, sizeof (opt));
nn_assert (opt == 1000);
opt = 4;
test_setsockopt (sb, NN_SOL_SOCKET, NN_RCVMAXSIZE, &opt, sizeof (opt));
test_send (sc, "ABC");
test_recv (sb, "ABC");
test_send (sc, "ABCD");
test_recv (sb, "ABCD");
test_send (sc, "ABCDE");
test_drop (sb, ETIMEDOUT);
/* Increase the size limit, reconnect, then try sending again. The reason a
reconnect is necessary is because after a protocol violation, the
connecting socket will not continue automatic reconnection attempts. */
opt = 5;
test_setsockopt (sb, NN_SOL_SOCKET, NN_RCVMAXSIZE, &opt, sizeof (opt));
test_connect (sc, socket_address);
test_send (sc, "ABCDE");
test_recv (sb, "ABCDE");
test_close (sb);
test_close (sc);
test_text ();
/* Test closing a socket that is waiting to connect. */
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, socket_address);
nn_sleep (100);
test_close (sc);
return 0;
}
