riot-ci/RIOT
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

tests/gnrc_sock_udp: fix NDEBUG compile problem

Browse Source
This commit is contained in:
Gunar Schorcht 2020-02-25 09:28:59 +01:00
parent d508b0ca09
commit 72278d3463
1 changed files with 175 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

349
tests/gnrc_sock_udp/main.c
View File

@ -23,6 +23,7 @@
#include <stdio.h>
#include "net/sock/udp.h"
#include "test_utils/expect.h"
#include "xtimer.h"
#include "constants.h"
@ -47,8 +48,8 @@ static void test_sock_udp_create__EADDRINUSE(void)
static const sock_udp_ep_t local = { .family = AF_INET6,
.port = _TEST_PORT_LOCAL };
assert(0 == sock_udp_create(&_sock, &local, NULL, 0));
assert(-EADDRINUSE == sock_udp_create(&_sock2, &local, NULL, 0));
expect(0 == sock_udp_create(&_sock, &local, NULL, 0));
expect(-EADDRINUSE == sock_udp_create(&_sock2, &local, NULL, 0));
}
#endif
@ -61,8 +62,8 @@ static void test_sock_udp_create__EAFNOSUPPORT(void)
static const sock_udp_ep_t remote = { .family = AF_UNSPEC,
.port = _TEST_PORT_REMOTE };
assert(-EAFNOSUPPORT == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
assert(-EAFNOSUPPORT == sock_udp_create(&_sock, NULL, &remote, SOCK_FLAGS_REUSE_EP));
expect(-EAFNOSUPPORT == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
expect(-EAFNOSUPPORT == sock_udp_create(&_sock, NULL, &remote, SOCK_FLAGS_REUSE_EP));
}
static void test_sock_udp_create__EINVAL_addr(void)
@ -75,7 +76,7 @@ static void test_sock_udp_create__EINVAL_addr(void)
.netif = _TEST_NETIF,
.port = _TEST_PORT_REMOTE };
assert(-EINVAL == sock_udp_create(&_sock, &local, &remote, SOCK_FLAGS_REUSE_EP));
expect(-EINVAL == sock_udp_create(&_sock, &local, &remote, SOCK_FLAGS_REUSE_EP));
}
static void test_sock_udp_create__EINVAL_netif(void)
@ -89,16 +90,16 @@ static void test_sock_udp_create__EINVAL_netif(void)
.port = _TEST_PORT_REMOTE,
.addr = { .ipv6 = _TEST_ADDR_REMOTE } };
assert(-EINVAL == sock_udp_create(&_sock, &local, &remote, SOCK_FLAGS_REUSE_EP));
expect(-EINVAL == sock_udp_create(&_sock, &local, &remote, SOCK_FLAGS_REUSE_EP));
}
static void test_sock_udp_create__no_endpoints(void)
{
sock_udp_ep_t ep;
assert(0 == sock_udp_create(&_sock, NULL, NULL, SOCK_FLAGS_REUSE_EP));
assert(-EADDRNOTAVAIL == sock_udp_get_local(&_sock, &ep));
assert(-ENOTCONN == sock_udp_get_remote(&_sock, &ep));
expect(0 == sock_udp_create(&_sock, NULL, NULL, SOCK_FLAGS_REUSE_EP));
expect(-EADDRNOTAVAIL == sock_udp_get_local(&_sock, &ep));
expect(-ENOTCONN == sock_udp_get_remote(&_sock, &ep));
}
static void test_sock_udp_create__only_local(void)
@ -107,14 +108,14 @@ static void test_sock_udp_create__only_local(void)
.port = _TEST_PORT_LOCAL };
sock_udp_ep_t ep;
assert(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
assert(0 == sock_udp_get_local(&_sock, &ep));
assert(AF_INET6 == ep.family);
assert(memcmp(&ipv6_addr_unspecified, &ep.addr.ipv6,
expect(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
expect(0 == sock_udp_get_local(&_sock, &ep));
expect(AF_INET6 == ep.family);
expect(memcmp(&ipv6_addr_unspecified, &ep.addr.ipv6,
sizeof(ipv6_addr_t)) == 0);
assert(SOCK_ADDR_ANY_NETIF == ep.netif);
assert(_TEST_PORT_LOCAL == ep.port);
assert(-ENOTCONN == sock_udp_get_remote(&_sock, &ep));
expect(SOCK_ADDR_ANY_NETIF == ep.netif);
expect(_TEST_PORT_LOCAL == ep.port);
expect(-ENOTCONN == sock_udp_get_remote(&_sock, &ep));
}
static void test_sock_udp_create__only_local_port0(void)
@ -123,14 +124,14 @@ static void test_sock_udp_create__only_local_port0(void)
.port = 0U };
sock_udp_ep_t ep;
assert(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
assert(0 == sock_udp_get_local(&_sock, &ep));
assert(AF_INET6 == ep.family);
assert(memcmp(&ipv6_addr_unspecified, &ep.addr.ipv6,
expect(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
expect(0 == sock_udp_get_local(&_sock, &ep));
expect(AF_INET6 == ep.family);
expect(memcmp(&ipv6_addr_unspecified, &ep.addr.ipv6,
sizeof(ipv6_addr_t)) == 0);
assert(SOCK_ADDR_ANY_NETIF == ep.netif);
assert(0U != ep.port);
assert(-ENOTCONN == sock_udp_get_remote(&_sock, &ep));
expect(SOCK_ADDR_ANY_NETIF == ep.netif);
expect(0U != ep.port);
expect(-ENOTCONN == sock_udp_get_remote(&_sock, &ep));
}
static void test_sock_udp_create__only_local_reuse_ep(void)
@ -139,22 +140,22 @@ static void test_sock_udp_create__only_local_reuse_ep(void)
.port = _TEST_PORT_LOCAL };
sock_udp_ep_t ep, ep2;
assert(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
assert(0 == sock_udp_create(&_sock2, &local, NULL, SOCK_FLAGS_REUSE_EP));
assert(0 == sock_udp_get_local(&_sock, &ep));
assert(0 == sock_udp_get_local(&_sock2, &ep2));
assert(AF_INET6 == ep.family);
assert(memcmp(&ipv6_addr_unspecified, &ep.addr.ipv6,
expect(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
expect(0 == sock_udp_create(&_sock2, &local, NULL, SOCK_FLAGS_REUSE_EP));
expect(0 == sock_udp_get_local(&_sock, &ep));
expect(0 == sock_udp_get_local(&_sock2, &ep2));
expect(AF_INET6 == ep.family);
expect(memcmp(&ipv6_addr_unspecified, &ep.addr.ipv6,
sizeof(ipv6_addr_t)) == 0);
assert(SOCK_ADDR_ANY_NETIF == ep.netif);
assert(_TEST_PORT_LOCAL == ep.port);
assert(-ENOTCONN == sock_udp_get_remote(&_sock, &ep));
assert(AF_INET6 == ep2.family);
assert(memcmp(&ipv6_addr_unspecified, &ep2.addr.ipv6,
expect(SOCK_ADDR_ANY_NETIF == ep.netif);
expect(_TEST_PORT_LOCAL == ep.port);
expect(-ENOTCONN == sock_udp_get_remote(&_sock, &ep));
expect(AF_INET6 == ep2.family);
expect(memcmp(&ipv6_addr_unspecified, &ep2.addr.ipv6,
sizeof(ipv6_addr_t)) == 0);
assert(SOCK_ADDR_ANY_NETIF == ep2.netif);
assert(_TEST_PORT_LOCAL == ep2.port);
assert(-ENOTCONN == sock_udp_get_remote(&_sock, &ep2));
expect(SOCK_ADDR_ANY_NETIF == ep2.netif);
expect(_TEST_PORT_LOCAL == ep2.port);
expect(-ENOTCONN == sock_udp_get_remote(&_sock, &ep2));
sock_udp_close(&_sock2);
}
@ -166,13 +167,13 @@ static void test_sock_udp_create__only_remote(void)
.addr = { .ipv6 = _TEST_ADDR_REMOTE } };
sock_udp_ep_t ep;
assert(0 == sock_udp_create(&_sock, NULL, &remote, SOCK_FLAGS_REUSE_EP));
assert(-EADDRNOTAVAIL == sock_udp_get_local(&_sock, &ep));
assert(0 == sock_udp_get_remote(&_sock, &ep));
assert(AF_INET6 == ep.family);
assert(memcmp(&remote_addr, &ep.addr.ipv6, sizeof(ipv6_addr_t)) == 0);
assert(SOCK_ADDR_ANY_NETIF == ep.netif);
assert(_TEST_PORT_REMOTE == ep.port);
expect(0 == sock_udp_create(&_sock, NULL, &remote, SOCK_FLAGS_REUSE_EP));
expect(-EADDRNOTAVAIL == sock_udp_get_local(&_sock, &ep));
expect(0 == sock_udp_get_remote(&_sock, &ep));
expect(AF_INET6 == ep.family);
expect(memcmp(&remote_addr, &ep.addr.ipv6, sizeof(ipv6_addr_t)) == 0);
expect(SOCK_ADDR_ANY_NETIF == ep.netif);
expect(_TEST_PORT_REMOTE == ep.port);
}
static void test_sock_udp_create__full(void)
@ -185,25 +186,25 @@ static void test_sock_udp_create__full(void)
.addr = { .ipv6 = _TEST_ADDR_REMOTE } };
sock_udp_ep_t ep;
assert(0 == sock_udp_create(&_sock, &local, &remote, SOCK_FLAGS_REUSE_EP));
assert(0 == sock_udp_get_local(&_sock, &ep));
assert(AF_INET6 == ep.family);
assert(memcmp(&ipv6_addr_unspecified, &ep.addr.ipv6,
expect(0 == sock_udp_create(&_sock, &local, &remote, SOCK_FLAGS_REUSE_EP));
expect(0 == sock_udp_get_local(&_sock, &ep));
expect(AF_INET6 == ep.family);
expect(memcmp(&ipv6_addr_unspecified, &ep.addr.ipv6,
sizeof(ipv6_addr_t)) == 0);
assert(_TEST_NETIF == ep.netif);
assert(_TEST_PORT_LOCAL == ep.port);
assert(0 == sock_udp_get_remote(&_sock, &ep));
assert(AF_INET6 == ep.family);
assert(memcmp(&remote_addr, &ep.addr.ipv6, sizeof(ipv6_addr_t)) == 0);
assert(SOCK_ADDR_ANY_NETIF == ep.netif);
assert(_TEST_PORT_REMOTE == ep.port);
expect(_TEST_NETIF == ep.netif);
expect(_TEST_PORT_LOCAL == ep.port);
expect(0 == sock_udp_get_remote(&_sock, &ep));
expect(AF_INET6 == ep.family);
expect(memcmp(&remote_addr, &ep.addr.ipv6, sizeof(ipv6_addr_t)) == 0);
expect(SOCK_ADDR_ANY_NETIF == ep.netif);
expect(_TEST_PORT_REMOTE == ep.port);
}
static void test_sock_udp_recv__EADDRNOTAVAIL(void)
{
assert(0 == sock_udp_create(&_sock, NULL, NULL, SOCK_FLAGS_REUSE_EP));
expect(0 == sock_udp_create(&_sock, NULL, NULL, SOCK_FLAGS_REUSE_EP));
assert(-EADDRNOTAVAIL == sock_udp_recv(&_sock, _test_buffer,
expect(-EADDRNOTAVAIL == sock_udp_recv(&_sock, _test_buffer,
sizeof(_test_buffer),
SOCK_NO_TIMEOUT, NULL));
}
@ -213,9 +214,9 @@ static void test_sock_udp_recv__EAGAIN(void)
static const sock_udp_ep_t local = { .family = AF_INET6, .netif = _TEST_NETIF,
.port = _TEST_PORT_LOCAL };
assert(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
expect(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
assert(-EAGAIN == sock_udp_recv(&_sock, _test_buffer, sizeof(_test_buffer),
expect(-EAGAIN == sock_udp_recv(&_sock, _test_buffer, sizeof(_test_buffer),
0, NULL));
}
@ -226,12 +227,12 @@ static void test_sock_udp_recv__ENOBUFS(void)
static const sock_udp_ep_t local = { .family = AF_INET6,
.port = _TEST_PORT_LOCAL };
assert(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
assert(_inject_packet(&src_addr, &dst_addr, _TEST_PORT_REMOTE,
expect(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
expect(_inject_packet(&src_addr, &dst_addr, _TEST_PORT_REMOTE,
_TEST_PORT_LOCAL, "ABCD", sizeof("ABCD"), _TEST_NETIF));
assert(-ENOBUFS == sock_udp_recv(&_sock, _test_buffer, 2, SOCK_NO_TIMEOUT,
expect(-ENOBUFS == sock_udp_recv(&_sock, _test_buffer, 2, SOCK_NO_TIMEOUT,
NULL));
assert(_check_net());
expect(_check_net());
}
static void test_sock_udp_recv__EPROTO(void)
@ -244,13 +245,13 @@ static void test_sock_udp_recv__EPROTO(void)
.family = AF_INET6,
.port = _TEST_PORT_REMOTE };
assert(0 == sock_udp_create(&_sock, &local, &remote, SOCK_FLAGS_REUSE_EP));
assert(_inject_packet(&src_addr, &dst_addr, _TEST_PORT_REMOTE,
expect(0 == sock_udp_create(&_sock, &local, &remote, SOCK_FLAGS_REUSE_EP));
expect(_inject_packet(&src_addr, &dst_addr, _TEST_PORT_REMOTE,
_TEST_PORT_LOCAL, "ABCD", sizeof("ABCD"),
_TEST_NETIF));
assert(-EPROTO == sock_udp_recv(&_sock, _test_buffer, sizeof(_test_buffer),
expect(-EPROTO == sock_udp_recv(&_sock, _test_buffer, sizeof(_test_buffer),
SOCK_NO_TIMEOUT, NULL));
assert(_check_net());
expect(_check_net());
}
static void test_sock_udp_recv__ETIMEDOUT(void)
@ -258,10 +259,10 @@ static void test_sock_udp_recv__ETIMEDOUT(void)
static const sock_udp_ep_t local = { .family = AF_INET6, .netif = _TEST_NETIF,
.port = _TEST_PORT_LOCAL };
assert(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
expect(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
puts(" * Calling sock_udp_recv()");
assert(-ETIMEDOUT == sock_udp_recv(&_sock, _test_buffer,
expect(-ETIMEDOUT == sock_udp_recv(&_sock, _test_buffer,
sizeof(_test_buffer), _TEST_TIMEOUT,
NULL));
printf(" * (timed out with timeout %lu)\n", (long unsigned)_TEST_TIMEOUT);
@ -277,14 +278,14 @@ static void test_sock_udp_recv__socketed(void)
.family = AF_INET6,
.port = _TEST_PORT_REMOTE };
assert(0 == sock_udp_create(&_sock, &local, &remote, SOCK_FLAGS_REUSE_EP));
assert(_inject_packet(&src_addr, &dst_addr, _TEST_PORT_REMOTE,
expect(0 == sock_udp_create(&_sock, &local, &remote, SOCK_FLAGS_REUSE_EP));
expect(_inject_packet(&src_addr, &dst_addr, _TEST_PORT_REMOTE,
_TEST_PORT_LOCAL, "ABCD", sizeof("ABCD"),
_TEST_NETIF));
assert(sizeof("ABCD") == sock_udp_recv(&_sock, _test_buffer,
expect(sizeof("ABCD") == sock_udp_recv(&_sock, _test_buffer,
sizeof(_test_buffer),
SOCK_NO_TIMEOUT, NULL));
assert(_check_net());
expect(_check_net());
}
static void test_sock_udp_recv__socketed_with_remote(void)
@ -298,18 +299,18 @@ static void test_sock_udp_recv__socketed_with_remote(void)
.port = _TEST_PORT_REMOTE };
sock_udp_ep_t result;
assert(0 == sock_udp_create(&_sock, &local, &remote, SOCK_FLAGS_REUSE_EP));
assert(_inject_packet(&src_addr, &dst_addr, _TEST_PORT_REMOTE,
expect(0 == sock_udp_create(&_sock, &local, &remote, SOCK_FLAGS_REUSE_EP));
expect(_inject_packet(&src_addr, &dst_addr, _TEST_PORT_REMOTE,
_TEST_PORT_LOCAL, "ABCD", sizeof("ABCD"),
_TEST_NETIF));
assert(sizeof("ABCD") == sock_udp_recv(&_sock, _test_buffer,
expect(sizeof("ABCD") == sock_udp_recv(&_sock, _test_buffer,
sizeof(_test_buffer),
SOCK_NO_TIMEOUT, &result));
assert(AF_INET6 == result.family);
assert(memcmp(&result.addr, &src_addr, sizeof(result.addr)) == 0);
assert(_TEST_PORT_REMOTE == result.port);
assert(_TEST_NETIF == result.netif);
assert(_check_net());
expect(AF_INET6 == result.family);
expect(memcmp(&result.addr, &src_addr, sizeof(result.addr)) == 0);
expect(_TEST_PORT_REMOTE == result.port);
expect(_TEST_NETIF == result.netif);
expect(_check_net());
}
static void test_sock_udp_recv__socketed_with_port0(void)
@ -322,20 +323,20 @@ static void test_sock_udp_recv__socketed_with_port0(void)
.port = _TEST_PORT_REMOTE };
sock_udp_ep_t result;
assert(0 == sock_udp_create(&_sock, &local, &remote, SOCK_FLAGS_REUSE_EP));
assert(0 == sock_udp_get_local(&_sock, &local));
assert(0 != local.port);
assert(_inject_packet(&src_addr, &dst_addr, _TEST_PORT_REMOTE,
expect(0 == sock_udp_create(&_sock, &local, &remote, SOCK_FLAGS_REUSE_EP));
expect(0 == sock_udp_get_local(&_sock, &local));
expect(0 != local.port);
expect(_inject_packet(&src_addr, &dst_addr, _TEST_PORT_REMOTE,
local.port, "ABCD", sizeof("ABCD"),
_TEST_NETIF));
assert(sizeof("ABCD") == sock_udp_recv(&_sock, _test_buffer,
expect(sizeof("ABCD") == sock_udp_recv(&_sock, _test_buffer,
sizeof(_test_buffer),
SOCK_NO_TIMEOUT, &result));
assert(AF_INET6 == result.family);
assert(memcmp(&result.addr, &src_addr, sizeof(result.addr)) == 0);
assert(_TEST_PORT_REMOTE == result.port);
assert(_TEST_NETIF == result.netif);
assert(_check_net());
expect(AF_INET6 == result.family);
expect(memcmp(&result.addr, &src_addr, sizeof(result.addr)) == 0);
expect(_TEST_PORT_REMOTE == result.port);
expect(_TEST_NETIF == result.netif);
expect(_check_net());
}
static void test_sock_udp_recv__unsocketed(void)
@ -346,14 +347,14 @@ static void test_sock_udp_recv__unsocketed(void)
.family = AF_INET6,
.port = _TEST_PORT_LOCAL };
assert(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
assert(_inject_packet(&src_addr, &dst_addr, _TEST_PORT_REMOTE,
expect(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
expect(_inject_packet(&src_addr, &dst_addr, _TEST_PORT_REMOTE,
_TEST_PORT_LOCAL, "ABCD", sizeof("ABCD"),
_TEST_NETIF));
assert(sizeof("ABCD") == sock_udp_recv(&_sock, _test_buffer,
expect(sizeof("ABCD") == sock_udp_recv(&_sock, _test_buffer,
sizeof(_test_buffer),
SOCK_NO_TIMEOUT, NULL));
assert(_check_net());
expect(_check_net());
}
static void test_sock_udp_recv__unsocketed_with_remote(void)
@ -364,18 +365,18 @@ static void test_sock_udp_recv__unsocketed_with_remote(void)
.port = _TEST_PORT_LOCAL };
sock_udp_ep_t result;
assert(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
assert(_inject_packet(&src_addr, &dst_addr, _TEST_PORT_REMOTE,
expect(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
expect(_inject_packet(&src_addr, &dst_addr, _TEST_PORT_REMOTE,
_TEST_PORT_LOCAL, "ABCD", sizeof("ABCD"),
_TEST_NETIF));
assert(sizeof("ABCD") == sock_udp_recv(&_sock, _test_buffer,
expect(sizeof("ABCD") == sock_udp_recv(&_sock, _test_buffer,
sizeof(_test_buffer),
SOCK_NO_TIMEOUT, &result));
assert(AF_INET6 == result.family);
assert(memcmp(&result.addr, &src_addr, sizeof(result.addr)) == 0);
assert(_TEST_PORT_REMOTE == result.port);
assert(_TEST_NETIF == result.netif);
assert(_check_net());
expect(AF_INET6 == result.family);
expect(memcmp(&result.addr, &src_addr, sizeof(result.addr)) == 0);
expect(_TEST_PORT_REMOTE == result.port);
expect(_TEST_NETIF == result.netif);
expect(_check_net());
}
static void test_sock_udp_recv__with_timeout(void)
@ -386,18 +387,18 @@ static void test_sock_udp_recv__with_timeout(void)
.port = _TEST_PORT_LOCAL };
sock_udp_ep_t result;
assert(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
assert(_inject_packet(&src_addr, &dst_addr, _TEST_PORT_REMOTE,
expect(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
expect(_inject_packet(&src_addr, &dst_addr, _TEST_PORT_REMOTE,
_TEST_PORT_LOCAL, "ABCD", sizeof("ABCD"),
_TEST_NETIF));
assert(sizeof("ABCD") == sock_udp_recv(&_sock, _test_buffer,
expect(sizeof("ABCD") == sock_udp_recv(&_sock, _test_buffer,
sizeof(_test_buffer), _TEST_TIMEOUT,
&result));
assert(AF_INET6 == result.family);
assert(memcmp(&result.addr, &src_addr, sizeof(result.addr)) == 0);
assert(_TEST_PORT_REMOTE == result.port);
assert(_TEST_NETIF == result.netif);
assert(_check_net());
expect(AF_INET6 == result.family);
expect(memcmp(&result.addr, &src_addr, sizeof(result.addr)) == 0);
expect(_TEST_PORT_REMOTE == result.port);
expect(_TEST_NETIF == result.netif);
expect(_check_net());
}
static void test_sock_udp_recv__non_blocking(void)
@ -408,17 +409,17 @@ static void test_sock_udp_recv__non_blocking(void)
.port = _TEST_PORT_LOCAL };
sock_udp_ep_t result;
assert(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
assert(_inject_packet(&src_addr, &dst_addr, _TEST_PORT_REMOTE,
expect(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
expect(_inject_packet(&src_addr, &dst_addr, _TEST_PORT_REMOTE,
_TEST_PORT_LOCAL, "ABCD", sizeof("ABCD"),
_TEST_NETIF));
assert(sizeof("ABCD") == sock_udp_recv(&_sock, _test_buffer,
expect(sizeof("ABCD") == sock_udp_recv(&_sock, _test_buffer,
sizeof(_test_buffer), 0, &result));
assert(AF_INET6 == result.family);
assert(memcmp(&result.addr, &src_addr, sizeof(result.addr)) == 0);
assert(_TEST_PORT_REMOTE == result.port);
assert(_TEST_NETIF == result.netif);
assert(_check_net());
expect(AF_INET6 == result.family);
expect(memcmp(&result.addr, &src_addr, sizeof(result.addr)) == 0);
expect(_TEST_PORT_REMOTE == result.port);
expect(_TEST_NETIF == result.netif);
expect(_check_net());
}
static void test_sock_udp_send__EAFNOSUPPORT(void)
@ -427,9 +428,9 @@ static void test_sock_udp_send__EAFNOSUPPORT(void)
.family = AF_INET,
.port = _TEST_PORT_REMOTE };
assert(-EAFNOSUPPORT == sock_udp_send(NULL, "ABCD", sizeof("ABCD"),
expect(-EAFNOSUPPORT == sock_udp_send(NULL, "ABCD", sizeof("ABCD"),
&remote));
assert(_check_net());
expect(_check_net());
}
static void test_sock_udp_send__EINVAL_addr(void)
@ -442,9 +443,9 @@ static void test_sock_udp_send__EINVAL_addr(void)
.port = _TEST_PORT_REMOTE,
.netif = _TEST_NETIF };
assert(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
assert(-EINVAL == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"), &remote));
assert(_check_net());
expect(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
expect(-EINVAL == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"), &remote));
expect(_check_net());
}
static void test_sock_udp_send__EINVAL_netif(void)
@ -458,9 +459,9 @@ static void test_sock_udp_send__EINVAL_netif(void)
.port = _TEST_PORT_REMOTE,
.netif = _TEST_NETIF + 1 };
assert(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
assert(-EINVAL == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"), &remote));
assert(_check_net());
expect(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
expect(-EINVAL == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"), &remote));
expect(_check_net());
}
static void test_sock_udp_send__EINVAL_port(void)
@ -468,15 +469,15 @@ static void test_sock_udp_send__EINVAL_port(void)
static const sock_udp_ep_t remote = { .addr = { .ipv6 = _TEST_ADDR_REMOTE },
.family = AF_INET6 };
assert(-EINVAL == sock_udp_send(NULL, "ABCD", sizeof("ABCD"), &remote));
assert(_check_net());
expect(-EINVAL == sock_udp_send(NULL, "ABCD", sizeof("ABCD"), &remote));
expect(_check_net());
}
static void test_sock_udp_send__ENOTCONN(void)
{
assert(0 == sock_udp_create(&_sock, NULL, NULL, SOCK_FLAGS_REUSE_EP));
assert(-ENOTCONN == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"), NULL));
assert(_check_net());
expect(0 == sock_udp_create(&_sock, NULL, NULL, SOCK_FLAGS_REUSE_EP));
expect(-ENOTCONN == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"), NULL));
expect(_check_net());
}
static void test_sock_udp_send__socketed_no_local_no_netif(void)
@ -486,14 +487,14 @@ static void test_sock_udp_send__socketed_no_local_no_netif(void)
.family = AF_INET6,
.port = _TEST_PORT_REMOTE };
assert(0 == sock_udp_create(&_sock, NULL, &remote, SOCK_FLAGS_REUSE_EP));
assert(sizeof("ABCD") == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"),
expect(0 == sock_udp_create(&_sock, NULL, &remote, SOCK_FLAGS_REUSE_EP));
expect(sizeof("ABCD") == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"),
NULL));
assert(_check_packet(&ipv6_addr_unspecified, &dst_addr, 0,
expect(_check_packet(&ipv6_addr_unspecified, &dst_addr, 0,
_TEST_PORT_REMOTE, "ABCD", sizeof("ABCD"),
SOCK_ADDR_ANY_NETIF, true));
xtimer_usleep(1000); /* let GNRC stack finish */
assert(_check_net());
expect(_check_net());
}
static void test_sock_udp_send__socketed_no_netif(void)
@ -507,14 +508,14 @@ static void test_sock_udp_send__socketed_no_netif(void)
.family = AF_INET6,
.port = _TEST_PORT_REMOTE };
assert(0 == sock_udp_create(&_sock, &local, &remote, SOCK_FLAGS_REUSE_EP));
assert(sizeof("ABCD") == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"),
expect(0 == sock_udp_create(&_sock, &local, &remote, SOCK_FLAGS_REUSE_EP));
expect(sizeof("ABCD") == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"),
NULL));
assert(_check_packet(&src_addr, &dst_addr, _TEST_PORT_LOCAL,
expect(_check_packet(&src_addr, &dst_addr, _TEST_PORT_LOCAL,
_TEST_PORT_REMOTE, "ABCD", sizeof("ABCD"),
SOCK_ADDR_ANY_NETIF, false));
xtimer_usleep(1000); /* let GNRC stack finish */
assert(_check_net());
expect(_check_net());
}
static void test_sock_udp_send__socketed_no_local(void)
@ -525,14 +526,14 @@ static void test_sock_udp_send__socketed_no_local(void)
.netif = _TEST_NETIF,
.port = _TEST_PORT_REMOTE };
assert(0 == sock_udp_create(&_sock, NULL, &remote, SOCK_FLAGS_REUSE_EP));
assert(sizeof("ABCD") == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"),
expect(0 == sock_udp_create(&_sock, NULL, &remote, SOCK_FLAGS_REUSE_EP));
expect(sizeof("ABCD") == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"),
NULL));
assert(_check_packet(&ipv6_addr_unspecified, &dst_addr, 0,
expect(_check_packet(&ipv6_addr_unspecified, &dst_addr, 0,
_TEST_PORT_REMOTE, "ABCD", sizeof("ABCD"), _TEST_NETIF,
true));
xtimer_usleep(1000); /* let GNRC stack finish */
assert(_check_net());
expect(_check_net());
}
static void test_sock_udp_send__socketed(void)
@ -547,14 +548,14 @@ static void test_sock_udp_send__socketed(void)
.family = AF_INET6,
.port = _TEST_PORT_REMOTE };
assert(0 == sock_udp_create(&_sock, &local, &remote, SOCK_FLAGS_REUSE_EP));
assert(sizeof("ABCD") == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"),
expect(0 == sock_udp_create(&_sock, &local, &remote, SOCK_FLAGS_REUSE_EP));
expect(sizeof("ABCD") == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"),
NULL));
assert(_check_packet(&src_addr, &dst_addr, _TEST_PORT_LOCAL,
expect(_check_packet(&src_addr, &dst_addr, _TEST_PORT_LOCAL,
_TEST_PORT_REMOTE, "ABCD", sizeof("ABCD"),
_TEST_NETIF, false));
xtimer_usleep(1000); /* let GNRC stack finish */
assert(_check_net());
expect(_check_net());
}
static void test_sock_udp_send__socketed_other_remote(void)
@ -572,14 +573,14 @@ static void test_sock_udp_send__socketed_other_remote(void)
.family = AF_INET6,
.port = _TEST_PORT_REMOTE };
assert(0 == sock_udp_create(&_sock, &local, &sock_remote, SOCK_FLAGS_REUSE_EP));
assert(sizeof("ABCD") == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"),
expect(0 == sock_udp_create(&_sock, &local, &sock_remote, SOCK_FLAGS_REUSE_EP));
expect(sizeof("ABCD") == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"),
&remote));
assert(_check_packet(&src_addr, &dst_addr, _TEST_PORT_LOCAL,
expect(_check_packet(&src_addr, &dst_addr, _TEST_PORT_LOCAL,
_TEST_PORT_REMOTE, "ABCD", sizeof("ABCD"),
_TEST_NETIF, false));
xtimer_usleep(1000); /* let GNRC stack finish */
assert(_check_net());
expect(_check_net());
}
static void test_sock_udp_send__unsocketed_no_local_no_netif(void)
@ -589,14 +590,14 @@ static void test_sock_udp_send__unsocketed_no_local_no_netif(void)
.family = AF_INET6,
.port = _TEST_PORT_REMOTE };
assert(0 == sock_udp_create(&_sock, NULL, NULL, SOCK_FLAGS_REUSE_EP));
assert(sizeof("ABCD") == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"),
expect(0 == sock_udp_create(&_sock, NULL, NULL, SOCK_FLAGS_REUSE_EP));
expect(sizeof("ABCD") == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"),
&remote));
assert(_check_packet(&ipv6_addr_unspecified, &dst_addr, 0,
expect(_check_packet(&ipv6_addr_unspecified, &dst_addr, 0,
_TEST_PORT_REMOTE, "ABCD", sizeof("ABCD"),
SOCK_ADDR_ANY_NETIF, true));
xtimer_usleep(1000); /* let GNRC stack finish */
assert(_check_net());
expect(_check_net());
}
static void test_sock_udp_send__unsocketed_no_netif(void)
@ -610,14 +611,14 @@ static void test_sock_udp_send__unsocketed_no_netif(void)
.family = AF_INET6,
.port = _TEST_PORT_REMOTE };
assert(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
assert(sizeof("ABCD") == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"),
expect(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
expect(sizeof("ABCD") == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"),
&remote));
assert(_check_packet(&src_addr, &dst_addr, _TEST_PORT_LOCAL,
expect(_check_packet(&src_addr, &dst_addr, _TEST_PORT_LOCAL,
_TEST_PORT_REMOTE, "ABCD", sizeof("ABCD"),
SOCK_ADDR_ANY_NETIF, false));
xtimer_usleep(1000); /* let GNRC stack finish */
assert(_check_net());
expect(_check_net());
}
static void test_sock_udp_send__unsocketed_no_local(void)
@ -628,14 +629,14 @@ static void test_sock_udp_send__unsocketed_no_local(void)
.netif = _TEST_NETIF,
.port = _TEST_PORT_REMOTE };
assert(0 == sock_udp_create(&_sock, NULL, NULL, SOCK_FLAGS_REUSE_EP));
assert(sizeof("ABCD") == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"),
expect(0 == sock_udp_create(&_sock, NULL, NULL, SOCK_FLAGS_REUSE_EP));
expect(sizeof("ABCD") == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"),
&remote));
assert(_check_packet(&ipv6_addr_unspecified, &dst_addr, 0,
expect(_check_packet(&ipv6_addr_unspecified, &dst_addr, 0,
_TEST_PORT_REMOTE, "ABCD", sizeof("ABCD"), _TEST_NETIF,
true));
xtimer_usleep(1000); /* let GNRC stack finish */
assert(_check_net());
expect(_check_net());
}
static void test_sock_udp_send__unsocketed(void)
@ -650,14 +651,14 @@ static void test_sock_udp_send__unsocketed(void)
.family = AF_INET6,
.port = _TEST_PORT_REMOTE };
assert(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
assert(sizeof("ABCD") == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"),
expect(0 == sock_udp_create(&_sock, &local, NULL, SOCK_FLAGS_REUSE_EP));
expect(sizeof("ABCD") == sock_udp_send(&_sock, "ABCD", sizeof("ABCD"),
&remote));
assert(_check_packet(&src_addr, &dst_addr, _TEST_PORT_LOCAL,
expect(_check_packet(&src_addr, &dst_addr, _TEST_PORT_LOCAL,
_TEST_PORT_REMOTE, "ABCD", sizeof("ABCD"),
_TEST_NETIF, false));
xtimer_usleep(1000); /* let GNRC stack finish */
assert(_check_net());
expect(_check_net());
}
static void test_sock_udp_send__no_sock_no_netif(void)
@ -667,13 +668,13 @@ static void test_sock_udp_send__no_sock_no_netif(void)
.family = AF_INET6,
.port = _TEST_PORT_REMOTE };
assert(sizeof("ABCD") == sock_udp_send(NULL, "ABCD", sizeof("ABCD"),
expect(sizeof("ABCD") == sock_udp_send(NULL, "ABCD", sizeof("ABCD"),
&remote));
assert(_check_packet(&ipv6_addr_unspecified, &dst_addr, 0,
expect(_check_packet(&ipv6_addr_unspecified, &dst_addr, 0,
_TEST_PORT_REMOTE, "ABCD", sizeof("ABCD"),
SOCK_ADDR_ANY_NETIF, true));
xtimer_usleep(1000); /* let GNRC stack finish */
assert(_check_net());
expect(_check_net());
}
static void test_sock_udp_send__no_sock(void)
@ -684,13 +685,13 @@ static void test_sock_udp_send__no_sock(void)
.netif = _TEST_NETIF,
.port = _TEST_PORT_REMOTE };
assert(sizeof("ABCD") == sock_udp_send(NULL, "ABCD", sizeof("ABCD"),
expect(sizeof("ABCD") == sock_udp_send(NULL, "ABCD", sizeof("ABCD"),
&remote));
assert(_check_packet(&ipv6_addr_unspecified, &dst_addr, 0,
expect(_check_packet(&ipv6_addr_unspecified, &dst_addr, 0,
_TEST_PORT_REMOTE, "ABCD", sizeof("ABCD"),
_TEST_NETIF, true));
xtimer_usleep(1000); /* let GNRC stack finish */
assert(_check_net());
expect(_check_net());
}
int main(void)