/*
* Builds on get_req test, to test path with trailing slash.
*/
static void test_nanocoap__get_path_trailing_slash(void)
{
uint8_t buf[_BUF_SIZE];
coap_pkt_t pkt;
uint16_t msgid = 0xABCD;
uint8_t token[2] = {0xDA, 0xEC};
char path[] = "/time/";
size_t uri_opt_len = 6;
size_t len = coap_build_hdr((coap_hdr_t *)&buf[0], COAP_TYPE_NON,
&token[0], 2, COAP_METHOD_GET, msgid);
coap_pkt_init(&pkt, &buf[0], sizeof(buf), len);
len = coap_opt_add_string(&pkt, COAP_OPT_URI_PATH, &path[0], '/');
TEST_ASSERT_EQUAL_INT(uri_opt_len, len);
char uri[10] = {0};
coap_get_uri_path(&pkt, (uint8_t *)&uri[0]);
TEST_ASSERT_EQUAL_STRING((char *)path, (char *)uri);
}
static void test_netdev_dummy_add_cb_successful(void)
{
char src[] = TEST_STRING64;
size_t src_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char dest[] = TEST_STRING64;
size_t dest_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char data[] = TEST_STRING8;
#if UNITTESTS_NETDEV_DUMMY_MAX_PACKET < 8
size_t data_len = UNITTESTS_NETDEV_DUMMY_MAX_PACKET;
#else
size_t data_len = 8;
#endif
TEST_ASSERT_EQUAL_INT(0, dev->driver->add_receive_data_callback(dev,
_fill_received));
TEST_ASSERT_EQUAL_INT(0, unittest_netdev_dummy_fire_rcv_event(dev, src,
src_len, dest, dest_len, data, data_len));
TEST_ASSERT_EQUAL_INT(src_len, received_src_len);
TEST_ASSERT_EQUAL_INT(0, memcmp(received_src, src, src_len));
TEST_ASSERT_EQUAL_INT(dest_len, received_dst_len);
TEST_ASSERT_EQUAL_INT(0, memcmp(received_dst, dest, dest_len));
TEST_ASSERT_EQUAL_INT(data_len, received_data_len);
TEST_ASSERT_EQUAL_INT(0, memcmp(received_data, data, data_len));
}
void test_add_fd_with_pending_failing_connect ()
{
zmq::thread_ctx_t thread_ctx;
zmq::poller_t poller (thread_ctx);
zmq::fd_t bind_socket = socket (AF_INET, SOCK_STREAM, 0);
sockaddr_in addr = {0};
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
addr.sin_port = 0;
TEST_ASSERT_EQUAL_INT (0, bind (bind_socket,
reinterpret_cast<const sockaddr *> (&addr),
sizeof (addr)));
int addr_len = static_cast<int> (sizeof (addr));
TEST_ASSERT_EQUAL_INT (0, getsockname (bind_socket,
reinterpret_cast<sockaddr *> (&addr),
&addr_len));
zmq::fd_t connect_socket = socket (AF_INET, SOCK_STREAM, 0);
zmq::unblock_socket (connect_socket);
TEST_ASSERT_EQUAL_INT (
-1, connect (connect_socket, reinterpret_cast<const sockaddr *> (&addr),
sizeof (addr)));
TEST_ASSERT_EQUAL_INT (WSAEWOULDBLOCK, WSAGetLastError ());
test_events_t events (connect_socket, poller);
zmq::poller_t::handle_t handle = poller.add_fd (connect_socket, &events);
events.set_handle (handle);
poller.set_pollin (handle);
poller.start ();
wait_in_events (events);
int value;
int value_len = sizeof (value);
TEST_ASSERT_EQUAL_INT (0, getsockopt (connect_socket, SOL_SOCKET, SO_ERROR,
reinterpret_cast<char *> (&value),
&value_len));
TEST_ASSERT_EQUAL_INT (WSAECONNREFUSED, value);
// required cleanup
close (connect_socket);
close (bind_socket);
}
/*
* Builds on get_req test, to test max length path.
*/
static void test_nanocoap__get_max_path(void)
{
uint8_t buf[128];
coap_pkt_t pkt;
uint16_t msgid = 0xABCD;
uint8_t token[2] = {0xDA, 0xEC};
char path[] = "/23456789012345678901234567890123456789012345678901234567890123";
/* includes extra byte for option length > 12 */
size_t uri_opt_len = 64;
size_t len = coap_build_hdr((coap_hdr_t *)&buf[0], COAP_TYPE_NON,
&token[0], 2, COAP_METHOD_GET, msgid);
coap_pkt_init(&pkt, &buf[0], sizeof(buf), len);
len = coap_opt_add_string(&pkt, COAP_OPT_URI_PATH, &path[0], '/');
TEST_ASSERT_EQUAL_INT(uri_opt_len, len);
char uri[NANOCOAP_URI_MAX] = {0};
coap_get_uri(&pkt, (uint8_t *)&uri[0]);
TEST_ASSERT_EQUAL_STRING((char *)path, (char *)uri);
}
int test_defaults (int send_hwm_, int msg_cnt_)
{
// Set up bind socket
void *pub_socket = test_context_socket (ZMQ_PUB);
TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (pub_socket, "inproc://a"));
// Set up connect socket
void *sub_socket = test_context_socket (ZMQ_SUB);
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sub_socket, "inproc://a"));
//set a hwm on publisher
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (pub_socket, ZMQ_SNDHWM, &send_hwm_, sizeof (send_hwm_)));
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (sub_socket, ZMQ_SUBSCRIBE, 0, 0));
// Send until we block
int send_count = 0;
while (send_count < msg_cnt_
&& zmq_send (pub_socket, NULL, 0, ZMQ_DONTWAIT) == 0)
++send_count;
msleep (SETTLE_TIME);
// Now receive all sent messages
int recv_count = 0;
while (0 == zmq_recv (sub_socket, NULL, 0, ZMQ_DONTWAIT)) {
++recv_count;
}
TEST_ASSERT_EQUAL_INT (send_hwm_, recv_count);
// Clean up
test_context_socket_close (sub_socket);
test_context_socket_close (pub_socket);
return recv_count;
}
static void test_map_indefinite(void)
{
{
/* serialization */
TEST_ASSERT(cbor_serialize_map_indefinite(&stream));
TEST_ASSERT(cbor_serialize_int(&stream, 1));
TEST_ASSERT(cbor_serialize_byte_string(&stream, "1"));
TEST_ASSERT(cbor_serialize_int(&stream, 2));
TEST_ASSERT(cbor_serialize_byte_string(&stream, "2"));
TEST_ASSERT(cbor_write_break(&stream));
unsigned char data[] = {0xbf,
0x01, 0x41, 0x31, /* kv-pair 1 */
0x02, 0x41, 0x32, /* kv-pair 2 */
0xff
};
CBOR_CHECK_SERIALIZED(stream, data, sizeof(data));
/* deserialization */
size_t offset = cbor_deserialize_map_indefinite(&stream, 0);
int count = 0;
while (!cbor_at_break(&stream, offset)) {
int key;
char value[16];
size_t read_bytes;
offset += read_bytes = cbor_deserialize_int(&stream, offset, &key);
TEST_ASSERT(read_bytes);
offset += read_bytes = cbor_deserialize_byte_string(&stream, offset,
value, sizeof(value));
TEST_ASSERT(read_bytes);
++count;
}
TEST_ASSERT_EQUAL_INT(2, count);
TEST_ASSERT(cbor_at_end(&stream, offset));
}
}
TEST(NDSlist, listFlush_nonEmpty) {
TEST_ASSERT_EQUAL_INT(0, nds_list_size(list));
nds_list_insert_head(list, (nds_element_t) 1);
nds_list_insert_head(list, (nds_element_t) 2);
nds_list_insert_head(list, (nds_element_t) 3);
TEST_ASSERT_EQUAL_INT(3, nds_list_size(list));
nds_list_flush(list);
TEST_ASSERT_EQUAL_INT(0, nds_list_size(list));
TEST_ASSERT_NULL(nds_list_get_head(list));
TEST_ASSERT_NULL(nds_list_get_tail(list));
nds_list_insert_head(list, (nds_element_t) 1);
nds_list_insert_tail(list, (nds_element_t) 2);
TEST_ASSERT_EQUAL_INT(2, nds_list_size(list));
TEST_ASSERT_EQUAL_INT(1, nds_list_get_head(list));
TEST_ASSERT_EQUAL_INT(2, nds_list_get_tail(list));
nds_list_flush(list);
TEST_ASSERT_EQUAL_INT(0, nds_list_size(list));
TEST_ASSERT_NULL(nds_list_get_head(list));
TEST_ASSERT_NULL(nds_list_get_tail(list));
}
TEST(UniqueMap, MapPutUnique)
{
const int A = 0;
const int B = 4;
struct UniqueMap* map = create_unique_map(A, B);
int values[] = {1,2,3};
int k[3];
k[0] = map_put_unique(map, &values[0]);
TEST_ASSERT_TRUE(k[0] > A && k[0] < B);
k[1] = map_put_unique(map, &values[1]);
TEST_ASSERT_TRUE(k[1] > A && k[1] < B);
TEST_ASSERT_NOT_EQUAL(k[0], k[1]);
k[2] = map_put_unique(map, &values[2]);
TEST_ASSERT_TRUE(k[2] > A && k[2] < B);
TEST_ASSERT_NOT_EQUAL(k[0], k[2]);
TEST_ASSERT_NOT_EQUAL(k[1], k[2]);
TEST_ASSERT_EQUAL_INT(0, map_put_unique(map, &values[2]));
destroy_unique_map(map);
}
TEST(api_bignum, capi_truncate_div__4)
{
ScmObj bn1 = SCM_OBJ_INIT, bn2 = SCM_OBJ_INIT;
ScmObj quo = SCM_OBJ_INIT, rem = SCM_OBJ_INIT;
ScmObj expected_quo = SCM_OBJ_INIT, expected_rem = SCM_OBJ_INIT;
SCM_REFSTK_INIT_REG(&bn1, &bn2, &quo, &rem,
&expected_quo, &expected_rem);
bn1 = ut_read_cstr("-23058430092136939520");
bn2 = ut_read_cstr("-9223372036854775808");
TEST_ASSERT_TRUE(scm_bignum_p(bn1));
TEST_ASSERT_TRUE(scm_bignum_p(bn2));
expected_quo = ut_read_cstr("2");
expected_rem = ut_read_cstr("-4611686018427387904");
TEST_ASSERT_EQUAL_INT(0, scm_capi_truncate_div(bn1, bn2,
SCM_CSETTER_L(quo),
SCM_CSETTER_L(rem)));
TEST_ASSERT_SCM_TRUE(scm_num_eq_P(expected_quo, quo));
TEST_ASSERT_SCM_TRUE(scm_num_eq_P(expected_rem, rem));
}
/* Server GET request success case. */
static void test_nanocoap__server_get_req(void)
{
uint8_t buf[_BUF_SIZE];
coap_pkt_t pkt;
char path[] = "/riot/value";
int res = _read_riot_value_req(&pkt, &buf[0]);
TEST_ASSERT_EQUAL_INT(0, res);
TEST_ASSERT_EQUAL_INT(COAP_METHOD_GET, coap_get_code(&pkt));
TEST_ASSERT_EQUAL_INT(2, coap_get_token_len(&pkt));
TEST_ASSERT_EQUAL_INT(4 + 2, coap_get_total_hdr_len(&pkt));
TEST_ASSERT_EQUAL_INT(COAP_TYPE_NON, coap_get_type(&pkt));
TEST_ASSERT_EQUAL_INT(0, pkt.payload_len);
char uri[64] = {0};
coap_get_uri_path(&pkt, (uint8_t *)&uri[0]);
TEST_ASSERT_EQUAL_STRING((char *)path, (char *)uri);
}
void test_routing_id ()
{
// Create the infrastructure
void *sc = test_context_socket (ZMQ_DEALER);
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc, "inproc://routing_id"));
void *sb = test_context_socket (ZMQ_ROUTER);
TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sb, "inproc://routing_id"));
// Send 2-part message.
TEST_ASSERT_EQUAL_INT (
1, TEST_ASSERT_SUCCESS_ERRNO (zmq_send (sc, "A", 1, ZMQ_SNDMORE)));
TEST_ASSERT_EQUAL_INT (
1, TEST_ASSERT_SUCCESS_ERRNO (zmq_send (sc, "B", 1, 0)));
// Routing id comes first.
zmq_msg_t msg;
TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&msg));
TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&msg, sb, 0));
TEST_ASSERT_EQUAL_INT (1, zmq_msg_more (&msg));
// Then the first part of the message body.
TEST_ASSERT_EQUAL_INT (
1, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&msg, sb, 0)));
TEST_ASSERT_EQUAL_INT (1, zmq_msg_more (&msg));
// And finally, the second part of the message body.
TEST_ASSERT_EQUAL_INT (
1, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&msg, sb, 0)));
TEST_ASSERT_EQUAL_INT (0, zmq_msg_more (&msg));
// Deallocate the infrastructure.
test_context_socket_close (sc);
test_context_socket_close (sb);
}
void test_data_can_create_complex_tree(void)
{
TEST_IGNORE();
int tree_data[] = { 4, 2, 6, 1, 3, 5, 7 };
node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));
TEST_ASSERT_NOT_NULL(tree);
TEST_ASSERT_EQUAL_INT(4, tree->data);
TEST_ASSERT_NOT_NULL(tree->left);
TEST_ASSERT_NOT_NULL(tree->right);
TEST_ASSERT_EQUAL_INT(2, tree->left->data);
TEST_ASSERT_NOT_NULL(tree->left->left);
TEST_ASSERT_NOT_NULL(tree->left->right);
TEST_ASSERT_EQUAL_INT(6, tree->right->data);
TEST_ASSERT_NOT_NULL(tree->right->left);
TEST_ASSERT_NOT_NULL(tree->right->right);
TEST_ASSERT_EQUAL_INT(1, tree->left->left->data);
TEST_ASSERT_NULL(tree->left->left->left);
TEST_ASSERT_NULL(tree->left->left->right);
TEST_ASSERT_EQUAL_INT(3, tree->left->right->data);
TEST_ASSERT_NULL(tree->left->right->left);
TEST_ASSERT_NULL(tree->left->right->right);
TEST_ASSERT_EQUAL_INT(5, tree->right->left->data);
TEST_ASSERT_NULL(tree->right->left->left);
TEST_ASSERT_NULL(tree->right->left->right);
TEST_ASSERT_EQUAL_INT(7, tree->right->right->data);
TEST_ASSERT_NULL(tree->right->right->left);
TEST_ASSERT_NULL(tree->right->right->right);
free_tree(tree);
}
static void test_pktbuf_add__in_place(void)
{
ng_pktsnip_t *pkt = ng_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16),
NG_NETTYPE_UNDEF);
ng_pktsnip_t *header;
TEST_ASSERT_NOT_NULL((header = ng_pktbuf_add(pkt, pkt->data, 4, NG_NETTYPE_UNDEF)));
TEST_ASSERT(header == pkt->next);
TEST_ASSERT_EQUAL_STRING(TEST_STRING16, header->data); /* there is no 0 byte */
TEST_ASSERT_EQUAL_INT(4, header->size);
TEST_ASSERT_EQUAL_INT(NG_NETTYPE_UNDEF, header->type);
TEST_ASSERT_EQUAL_INT(1, header->users);
TEST_ASSERT_EQUAL_STRING(TEST_STRING16 + 4, pkt->data);
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING16) - 4, pkt->size);
TEST_ASSERT_EQUAL_INT(NG_NETTYPE_UNDEF, pkt->type);
TEST_ASSERT_EQUAL_INT(1, pkt->users);
ng_pktbuf_release(header);
ng_pktbuf_release(pkt);
TEST_ASSERT(ng_pktbuf_is_empty());
}
/*
* Client GET request success case. Test request generation.
* Request /time resource from libcoap example
* Includes 2-byte token
*/
static void test_gcoap__client_get_req(void)
{
uint8_t buf[GCOAP_PDU_BUF_SIZE];
coap_pkt_t pdu;
size_t len;
char path[] = "/time";
uint8_t pdu_data[] = {
0x52, 0x01, 0xe6, 0x02, 0x9b, 0xce, 0xb4, 0x74,
0x69, 0x6d, 0x65
};
len = gcoap_request(&pdu, &buf[0], GCOAP_PDU_BUF_SIZE, COAP_METHOD_GET,
&path[0]);
TEST_ASSERT_EQUAL_INT(COAP_METHOD_GET, coap_get_code(&pdu));
TEST_ASSERT_EQUAL_INT(GCOAP_TOKENLEN, coap_get_token_len(&pdu));
TEST_ASSERT_EQUAL_INT(4 + GCOAP_TOKENLEN, coap_get_total_hdr_len(&pdu));
TEST_ASSERT_EQUAL_INT(COAP_TYPE_NON, coap_get_type(&pdu));
TEST_ASSERT_EQUAL_STRING(&path[0], (char *)&pdu.url[0]);
TEST_ASSERT_EQUAL_INT(0, pdu.payload_len);
TEST_ASSERT_EQUAL_INT(sizeof(pdu_data), len);
}
static void test_pkt_len__1_elem__size_data(void)
{
gnrc_pktsnip_t snip = _INIT_ELEM_STATIC_DATA(TEST_STRING8, NULL);
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING8), gnrc_pkt_len(&snip));
}
static void test_pkt_len__1_elem__size_0(void)
{
gnrc_pktsnip_t snip = _INIT_ELEM(0, NULL, NULL);
TEST_ASSERT_EQUAL_INT(0, gnrc_pkt_len(&snip));
}
static void test_pkt_len__NULL(void)
{
TEST_ASSERT_EQUAL_INT(0, gnrc_pkt_len(NULL));
}
static void test_pkt_count__null(void)
{
TEST_ASSERT_EQUAL_INT(0, gnrc_pkt_count(NULL));
}
static void test_stream_to_dealer ()
{
int rc;
char my_endpoint[MAX_SOCKET_STRING];
// We'll be using this socket in raw mode
void *stream = test_context_socket (ZMQ_STREAM);
int zero = 0;
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (stream, ZMQ_LINGER, &zero, sizeof (zero)));
int enabled = 1;
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (stream, ZMQ_STREAM_NOTIFY, &enabled, sizeof (enabled)));
bind_loopback_ipv4 (stream, my_endpoint, sizeof my_endpoint);
// We'll be using this socket as the other peer
void *dealer = test_context_socket (ZMQ_DEALER);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (dealer, ZMQ_LINGER, &zero, sizeof (zero)));
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (dealer, my_endpoint));
// Send a message on the dealer socket
send_string_expect_success (dealer, "Hello", 0);
// Connecting sends a zero message
// First frame is routing id
zmq_msg_t routing_id;
TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&routing_id));
TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&routing_id, stream, 0));
TEST_ASSERT_TRUE (zmq_msg_more (&routing_id));
// Verify the existence of Peer-Address metadata
char const *peer_address = zmq_msg_gets (&routing_id, "Peer-Address");
TEST_ASSERT_NOT_NULL (peer_address);
TEST_ASSERT_EQUAL_STRING ("127.0.0.1", peer_address);
// Second frame is zero
byte buffer[255];
TEST_ASSERT_EQUAL_INT (
0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (stream, buffer, 255, 0)));
// Verify the existence of Peer-Address metadata
peer_address = zmq_msg_gets (&routing_id, "Peer-Address");
TEST_ASSERT_NOT_NULL (peer_address);
TEST_ASSERT_EQUAL_STRING ("127.0.0.1", peer_address);
// Real data follows
// First frame is routing id
TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&routing_id, stream, 0));
TEST_ASSERT_TRUE (zmq_msg_more (&routing_id));
// Verify the existence of Peer-Address metadata
peer_address = zmq_msg_gets (&routing_id, "Peer-Address");
TEST_ASSERT_NOT_NULL (peer_address);
TEST_ASSERT_EQUAL_STRING ("127.0.0.1", peer_address);
// Second frame is greeting signature
recv_array_expect_success (stream, greeting.signature, 0);
// Send our own protocol greeting
TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_send (&routing_id, stream, ZMQ_SNDMORE));
TEST_ASSERT_EQUAL_INT (
sizeof (greeting), TEST_ASSERT_SUCCESS_ERRNO (
zmq_send (stream, &greeting, sizeof (greeting), 0)));
// Now we expect the data from the DEALER socket
// We want the rest of greeting along with the Ready command
int bytes_read = 0;
while (bytes_read < 97) {
// First frame is the routing id of the connection (each time)
TEST_ASSERT_GREATER_THAN_INT (
0, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&routing_id, stream, 0)));
TEST_ASSERT_TRUE (zmq_msg_more (&routing_id));
// Second frame contains the next chunk of data
TEST_ASSERT_SUCCESS_ERRNO (
rc = zmq_recv (stream, buffer + bytes_read, 255 - bytes_read, 0));
bytes_read += rc;
}
// First two bytes are major and minor version numbers.
TEST_ASSERT_EQUAL_INT (3, buffer[0]); // ZMTP/3.0
TEST_ASSERT_EQUAL_INT (0, buffer[1]);
// Mechanism is "NULL"
TEST_ASSERT_EQUAL_INT8_ARRAY (buffer + 2,
"NULL\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 20);
TEST_ASSERT_EQUAL_INT8_ARRAY (buffer + 54, "\4\51\5READY", 8);
TEST_ASSERT_EQUAL_INT8_ARRAY (buffer + 62, "\13Socket-Type\0\0\0\6DEALER",
22);
TEST_ASSERT_EQUAL_INT8_ARRAY (buffer + 84, "\10Identity\0\0\0\0", 13);
// Announce we are ready
memcpy (buffer, "\4\51\5READY", 8);
memcpy (buffer + 8, "\13Socket-Type\0\0\0\6ROUTER", 22);
memcpy (buffer + 30, "\10Identity\0\0\0\0", 13);
// Send Ready command
TEST_ASSERT_GREATER_THAN_INT (0, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_send (
&routing_id, stream, ZMQ_SNDMORE)));
TEST_ASSERT_EQUAL_INT (
43, TEST_ASSERT_SUCCESS_ERRNO (zmq_send (stream, buffer, 43, 0)));
// Now we expect the data from the DEALER socket
// First frame is, again, the routing id of the connection
TEST_ASSERT_GREATER_THAN_INT (
0, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&routing_id, stream, 0)));
TEST_ASSERT_TRUE (zmq_msg_more (&routing_id));
// Third frame contains Hello message from DEALER
TEST_ASSERT_EQUAL_INT (7, TEST_ASSERT_SUCCESS_ERRNO (
zmq_recv (stream, buffer, sizeof buffer, 0)));
// Then we have a 5-byte message "Hello"
TEST_ASSERT_EQUAL_INT (0, buffer[0]); // Flags = 0
TEST_ASSERT_EQUAL_INT (5, buffer[1]); // Size = 5
TEST_ASSERT_EQUAL_INT8_ARRAY (buffer + 2, "Hello", 5);
// Send "World" back to DEALER
TEST_ASSERT_GREATER_THAN_INT (0, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_send (
&routing_id, stream, ZMQ_SNDMORE)));
byte world[] = {0, 5, 'W', 'o', 'r', 'l', 'd'};
TEST_ASSERT_EQUAL_INT (
sizeof (world),
TEST_ASSERT_SUCCESS_ERRNO (zmq_send (stream, world, sizeof (world), 0)));
// Expect response on DEALER socket
recv_string_expect_success (dealer, "World", 0);
// Test large messages over STREAM socket
#define size 64000
uint8_t msgout[size];
memset (msgout, 0xAB, size);
zmq_send (dealer, msgout, size, 0);
uint8_t msgin[9 + size];
memset (msgin, 0, 9 + size);
bytes_read = 0;
while (bytes_read < 9 + size) {
// Get routing id frame
TEST_ASSERT_GREATER_THAN_INT (
0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (stream, buffer, 256, 0)));
// Get next chunk
TEST_ASSERT_GREATER_THAN_INT (
0,
TEST_ASSERT_SUCCESS_ERRNO (rc = zmq_recv (stream, msgin + bytes_read,
9 + size - bytes_read, 0)));
bytes_read += rc;
}
for (int byte_nbr = 0; byte_nbr < size; byte_nbr++) {
TEST_ASSERT_EQUAL_UINT8 (0xAB, msgin[9 + byte_nbr]);
}
test_context_socket_close (dealer);
test_context_socket_close (stream);
}
static void test_stream_to_stream ()
{
char my_endpoint[MAX_SOCKET_STRING];
// Set-up our context and sockets
void *server = test_context_socket (ZMQ_STREAM);
int enabled = 1;
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (server, ZMQ_STREAM_NOTIFY, &enabled, sizeof (enabled)));
bind_loopback_ipv4 (server, my_endpoint, sizeof my_endpoint);
void *client = test_context_socket (ZMQ_STREAM);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (client, ZMQ_STREAM_NOTIFY, &enabled, sizeof (enabled)));
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (client, my_endpoint));
uint8_t id[256];
uint8_t buffer[256];
// Connecting sends a zero message
// Server: First frame is routing id, second frame is zero
TEST_ASSERT_GREATER_THAN_INT (
0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (server, id, 256, 0)));
TEST_ASSERT_EQUAL_INT (
0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (server, buffer, 256, 0)));
// Client: First frame is routing id, second frame is zero
TEST_ASSERT_GREATER_THAN_INT (
0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (client, id, 256, 0)));
TEST_ASSERT_EQUAL_INT (
0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (client, buffer, 256, 0)));
// Sent HTTP request on client socket
// Get server routing id
size_t id_size = sizeof id;
TEST_ASSERT_SUCCESS_ERRNO (
zmq_getsockopt (client, ZMQ_ROUTING_ID, id, &id_size));
// First frame is server routing id
TEST_ASSERT_EQUAL_INT ((int) id_size, TEST_ASSERT_SUCCESS_ERRNO (zmq_send (
client, id, id_size, ZMQ_SNDMORE)));
// Second frame is HTTP GET request
TEST_ASSERT_EQUAL_INT (
7, TEST_ASSERT_SUCCESS_ERRNO (zmq_send (client, "GET /\n\n", 7, 0)));
// Get HTTP request; ID frame and then request
TEST_ASSERT_GREATER_THAN_INT (
0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (server, id, 256, 0)));
TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (server, buffer, 256, 0));
TEST_ASSERT_EQUAL_INT8_ARRAY (buffer, "GET /\n\n", 7);
// Send reply back to client
char http_response[] = "HTTP/1.0 200 OK\r\n"
"Content-Type: text/plain\r\n"
"\r\n"
"Hello, World!";
TEST_ASSERT_SUCCESS_ERRNO (zmq_send (server, id, id_size, ZMQ_SNDMORE));
TEST_ASSERT_SUCCESS_ERRNO (
zmq_send (server, http_response, sizeof (http_response), ZMQ_SNDMORE));
// Send zero to close connection to client
TEST_ASSERT_SUCCESS_ERRNO (zmq_send (server, id, id_size, ZMQ_SNDMORE));
TEST_ASSERT_SUCCESS_ERRNO (zmq_send (server, NULL, 0, ZMQ_SNDMORE));
// Get reply at client and check that it's complete
TEST_ASSERT_GREATER_THAN_INT (
0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (client, id, 256, 0)));
TEST_ASSERT_EQUAL_INT (
sizeof http_response,
TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (client, buffer, 256, 0)));
TEST_ASSERT_EQUAL_INT8_ARRAY (buffer, http_response,
sizeof (http_response));
// // Get disconnection notification
// FIXME: why does this block? Bug in STREAM disconnect notification?
// id_size = zmq_recv (client, id, 256, 0);
// assert (id_size > 0);
// rc = zmq_recv (client, buffer, 256, 0);
// assert (rc == 0);
test_context_socket_close (server);
test_context_socket_close (client);
}
void test_do_gol_iteration(void)
{
init_gol(4,4);
table[1][1] = 1;
table[2][1] = 1;
table[1][2] = 1;
table[2][2] = 1;
// Block pattern
do_gol_iteration();
TEST_ASSERT_EQUAL_INT(1, table[1][1]);
TEST_ASSERT_EQUAL_INT(1, table[2][1]);
TEST_ASSERT_EQUAL_INT(1, table[1][2]);
TEST_ASSERT_EQUAL_INT(1, table[2][2]);
TEST_ASSERT_EQUAL_INT(0, table[0][0]);
TEST_ASSERT_EQUAL_INT(0, table[1][0]);
TEST_ASSERT_EQUAL_INT(0, table[2][0]);
TEST_ASSERT_EQUAL_INT(0, table[3][0]);
TEST_ASSERT_EQUAL_INT(0, table[0][1]);
TEST_ASSERT_EQUAL_INT(0, table[3][1]);
TEST_ASSERT_EQUAL_INT(0, table[0][2]);
TEST_ASSERT_EQUAL_INT(0, table[3][2]);
TEST_ASSERT_EQUAL_INT(0, table[0][3]);
TEST_ASSERT_EQUAL_INT(0, table[1][3]);
TEST_ASSERT_EQUAL_INT(0, table[2][3]);
TEST_ASSERT_EQUAL_INT(0, table[3][3]);
// Block pattern with an adjacent cell in the
// top-left corner, complete destruction
// after 4 iterations.
table[0][1] = 1;
do_gol_iteration();
TEST_ASSERT_EQUAL_INT(0, table[0][0]);
TEST_ASSERT_EQUAL_INT(1, table[1][0]);
TEST_ASSERT_EQUAL_INT(0, table[2][0]);
TEST_ASSERT_EQUAL_INT(0, table[3][0]);
TEST_ASSERT_EQUAL_INT(1, table[0][1]);
TEST_ASSERT_EQUAL_INT(0, table[1][1]);
TEST_ASSERT_EQUAL_INT(1, table[2][1]);
TEST_ASSERT_EQUAL_INT(0, table[3][1]);
TEST_ASSERT_EQUAL_INT(1, table[0][2]);
TEST_ASSERT_EQUAL_INT(0, table[1][2]);
TEST_ASSERT_EQUAL_INT(1, table[2][2]);
TEST_ASSERT_EQUAL_INT(0, table[3][2]);
TEST_ASSERT_EQUAL_INT(0, table[0][3]);
TEST_ASSERT_EQUAL_INT(0, table[1][3]);
TEST_ASSERT_EQUAL_INT(0, table[2][3]);
TEST_ASSERT_EQUAL_INT(0, table[3][3]);
do_gol_iteration();
TEST_ASSERT_EQUAL_INT(0, table[0][0]);
TEST_ASSERT_EQUAL_INT(1, table[1][0]);
TEST_ASSERT_EQUAL_INT(0, table[2][0]);
TEST_ASSERT_EQUAL_INT(0, table[3][0]);
TEST_ASSERT_EQUAL_INT(1, table[0][1]);
TEST_ASSERT_EQUAL_INT(0, table[1][1]);
TEST_ASSERT_EQUAL_INT(1, table[2][1]);
TEST_ASSERT_EQUAL_INT(0, table[3][1]);
TEST_ASSERT_EQUAL_INT(0, table[0][2]);
TEST_ASSERT_EQUAL_INT(0, table[1][2]);
TEST_ASSERT_EQUAL_INT(0, table[2][2]);
TEST_ASSERT_EQUAL_INT(0, table[3][2]);
TEST_ASSERT_EQUAL_INT(0, table[0][3]);
TEST_ASSERT_EQUAL_INT(0, table[1][3]);
TEST_ASSERT_EQUAL_INT(0, table[2][3]);
TEST_ASSERT_EQUAL_INT(0, table[3][3]);
do_gol_iteration();
TEST_ASSERT_EQUAL_INT(0, table[0][0]);
TEST_ASSERT_EQUAL_INT(1, table[1][0]);
TEST_ASSERT_EQUAL_INT(0, table[2][0]);
TEST_ASSERT_EQUAL_INT(0, table[3][0]);
TEST_ASSERT_EQUAL_INT(0, table[0][1]);
TEST_ASSERT_EQUAL_INT(1, table[1][1]);
TEST_ASSERT_EQUAL_INT(0, table[2][1]);
TEST_ASSERT_EQUAL_INT(0, table[3][1]);
TEST_ASSERT_EQUAL_INT(0, table[0][2]);
TEST_ASSERT_EQUAL_INT(0, table[1][2]);
TEST_ASSERT_EQUAL_INT(0, table[2][2]);
TEST_ASSERT_EQUAL_INT(0, table[3][2]);
TEST_ASSERT_EQUAL_INT(0, table[0][3]);
TEST_ASSERT_EQUAL_INT(0, table[1][3]);
TEST_ASSERT_EQUAL_INT(0, table[2][3]);
TEST_ASSERT_EQUAL_INT(0, table[3][3]);
do_gol_iteration();
TEST_ASSERT_EQUAL_INT(0, table[0][0]);
TEST_ASSERT_EQUAL_INT(0, table[1][0]);
TEST_ASSERT_EQUAL_INT(0, table[2][0]);
TEST_ASSERT_EQUAL_INT(0, table[3][0]);
TEST_ASSERT_EQUAL_INT(0, table[0][1]);
TEST_ASSERT_EQUAL_INT(0, table[1][1]);
TEST_ASSERT_EQUAL_INT(0, table[2][1]);
TEST_ASSERT_EQUAL_INT(0, table[3][1]);
TEST_ASSERT_EQUAL_INT(0, table[0][2]);
TEST_ASSERT_EQUAL_INT(0, table[1][2]);
TEST_ASSERT_EQUAL_INT(0, table[2][2]);
TEST_ASSERT_EQUAL_INT(0, table[3][2]);
TEST_ASSERT_EQUAL_INT(0, table[0][3]);
TEST_ASSERT_EQUAL_INT(0, table[1][3]);
TEST_ASSERT_EQUAL_INT(0, table[2][3]);
TEST_ASSERT_EQUAL_INT(0, table[3][3]);
}
void test_count_neighbours(void)
{
init_gol(1,1);
TEST_ASSERT_EQUAL_INT(0, count_neighbours(0, 0));
init_gol(2,2);
table[1][1] = 1;
table[1][0] = 1;
table[0][1] = 1;
table[0][0] = 1;
TEST_ASSERT_EQUAL_INT(3, count_neighbours(0, 0));
init_gol(3,3);
TEST_ASSERT_EQUAL_INT(0, count_neighbours(1, 1));
TEST_ASSERT_EQUAL_INT(0, count_neighbours(0, 0));
TEST_ASSERT_EQUAL_INT(0, count_neighbours(0, 2));
TEST_ASSERT_EQUAL_INT(0, count_neighbours(2, 0));
TEST_ASSERT_EQUAL_INT(0, count_neighbours(2, 2));
TEST_ASSERT_EQUAL_INT(0, count_neighbours(0, 1));
TEST_ASSERT_EQUAL_INT(0, count_neighbours(1, 0));
TEST_ASSERT_EQUAL_INT(0, count_neighbours(2, 1));
TEST_ASSERT_EQUAL_INT(0, count_neighbours(1, 2));
init_gol(3,3);
memset(table[0], 1, 3);
memset(table[1], 1, 3);
memset(table[2], 1, 3);
TEST_ASSERT_EQUAL_INT(8, count_neighbours(1, 1));
TEST_ASSERT_EQUAL_INT(3, count_neighbours(0, 0));
TEST_ASSERT_EQUAL_INT(3, count_neighbours(0, 2));
TEST_ASSERT_EQUAL_INT(3, count_neighbours(2, 0));
TEST_ASSERT_EQUAL_INT(3, count_neighbours(2, 2));
TEST_ASSERT_EQUAL_INT(5, count_neighbours(0, 1));
TEST_ASSERT_EQUAL_INT(5, count_neighbours(1, 0));
TEST_ASSERT_EQUAL_INT(5, count_neighbours(2, 1));
TEST_ASSERT_EQUAL_INT(5, count_neighbours(1, 2));
}
/**
* In case of TW_MR_SLA_NACK, TW_MT_SLA_ACK, TW_MR_SLA_ACK, TW_MT_SLA_NACK, TW_MT_DATA_NACK,
* TW_MT_DATA_ACK, TW_START or TW_REP_START next data byte from txRingBuffer, if available,
* shall be sent and interrupt cleared (TWINT).
* Set above mentioned two wire status, put one byte in txRingBuffer, call ISR and test if
* byte was consumed in ISR and TW_INT was set. For TW_MR_SLA_NACK, TW_MT_SLA_ACK,
* TW_MR_SLA_ACK, TW_MT_SLA_NACK, TW_MT_DATA_NACK and TW_MT_DATA_ACK two bytes need to be
* put into buffer (see previous test)
*/
static void TwoWirePlus_BaseTest_ISR_TC4(void)
{
TwoWirePlus_BaseTest_resetBuffer();
TWSR = TW_MR_SLA_NACK;
TwoWirePlus_txRingBuffer.buffer[TwoWirePlus_txRingBuffer.head] = 0xaa;
TwoWirePlus_incrementIndex(TwoWirePlus_txRingBuffer.head);
TwoWirePlus_txRingBuffer.buffer[TwoWirePlus_txRingBuffer.head] = 0x55;
TwoWirePlus_incrementIndex(TwoWirePlus_txRingBuffer.head);
TwoWirePlus_txRingBuffer.lastOperation = TWOWIREPLUS_LASTOPERATION_WRITE;
TWI_vect();
TEST_ASSERT_EQUAL_INT(0x55, TWDR);
TEST_ASSERT_EQUAL_INT((TWOWIREPLUS_BASETEST_TWCR_TWIE | TWOWIREPLUS_BASETEST_TWCR_TWEN | TWOWIREPLUS_BASETEST_TWCR_TWEA | TWOWIREPLUS_BASETEST_TWCR_TWINT), TWCR);
TwoWirePlus_BaseTest_resetBuffer();
TWSR = TW_MT_SLA_ACK;
TwoWirePlus_txRingBuffer.buffer[TwoWirePlus_txRingBuffer.head] = 0xaa;
TwoWirePlus_incrementIndex(TwoWirePlus_txRingBuffer.head);
TwoWirePlus_txRingBuffer.buffer[TwoWirePlus_txRingBuffer.head] = 0x55;
TwoWirePlus_incrementIndex(TwoWirePlus_txRingBuffer.head);
TwoWirePlus_txRingBuffer.lastOperation = TWOWIREPLUS_LASTOPERATION_WRITE;
TWI_vect();
TEST_ASSERT_EQUAL_INT(0x55, TWDR);
TEST_ASSERT_EQUAL_INT((TWOWIREPLUS_BASETEST_TWCR_TWIE | TWOWIREPLUS_BASETEST_TWCR_TWEN | TWOWIREPLUS_BASETEST_TWCR_TWEA | TWOWIREPLUS_BASETEST_TWCR_TWINT), TWCR);
TwoWirePlus_BaseTest_resetBuffer();
TWSR = TW_MR_SLA_ACK;
TwoWirePlus_txRingBuffer.buffer[TwoWirePlus_txRingBuffer.head] = 0xaa;
TwoWirePlus_incrementIndex(TwoWirePlus_txRingBuffer.head);
TwoWirePlus_txRingBuffer.buffer[TwoWirePlus_txRingBuffer.head] = 0x55;
TwoWirePlus_incrementIndex(TwoWirePlus_txRingBuffer.head);
TwoWirePlus_txRingBuffer.lastOperation = TWOWIREPLUS_LASTOPERATION_WRITE;
TWI_vect();
TEST_ASSERT_EQUAL_INT(0x55, TWDR);
TEST_ASSERT_EQUAL_INT((TWOWIREPLUS_BASETEST_TWCR_TWIE | TWOWIREPLUS_BASETEST_TWCR_TWEN | TWOWIREPLUS_BASETEST_TWCR_TWEA | TWOWIREPLUS_BASETEST_TWCR_TWINT), TWCR);
TwoWirePlus_BaseTest_resetBuffer();
TWSR = TW_MT_SLA_NACK;
TwoWirePlus_txRingBuffer.buffer[TwoWirePlus_txRingBuffer.head] = 0xaa;
TwoWirePlus_incrementIndex(TwoWirePlus_txRingBuffer.head);
TwoWirePlus_txRingBuffer.buffer[TwoWirePlus_txRingBuffer.head] = 0x55;
TwoWirePlus_incrementIndex(TwoWirePlus_txRingBuffer.head);
TwoWirePlus_txRingBuffer.lastOperation = TWOWIREPLUS_LASTOPERATION_WRITE;
TWI_vect();
TEST_ASSERT_EQUAL_INT(0x55, TWDR);
TEST_ASSERT_EQUAL_INT((TWOWIREPLUS_BASETEST_TWCR_TWIE | TWOWIREPLUS_BASETEST_TWCR_TWEN | TWOWIREPLUS_BASETEST_TWCR_TWEA | TWOWIREPLUS_BASETEST_TWCR_TWINT), TWCR);
TwoWirePlus_BaseTest_resetBuffer();
TWSR = TW_MT_DATA_ACK;
TwoWirePlus_txRingBuffer.buffer[TwoWirePlus_txRingBuffer.head] = 0xaa;
TwoWirePlus_incrementIndex(TwoWirePlus_txRingBuffer.head);
TwoWirePlus_txRingBuffer.buffer[TwoWirePlus_txRingBuffer.head] = 0x55;
TwoWirePlus_incrementIndex(TwoWirePlus_txRingBuffer.head);
TwoWirePlus_txRingBuffer.lastOperation = TWOWIREPLUS_LASTOPERATION_WRITE;
TWI_vect();
TEST_ASSERT_EQUAL_INT(0x55, TWDR);
TEST_ASSERT_EQUAL_INT((TWOWIREPLUS_BASETEST_TWCR_TWIE | TWOWIREPLUS_BASETEST_TWCR_TWEN | TWOWIREPLUS_BASETEST_TWCR_TWEA | TWOWIREPLUS_BASETEST_TWCR_TWINT), TWCR);
TwoWirePlus_BaseTest_resetBuffer();
TWSR = TW_START;
TwoWirePlus_txRingBuffer.buffer[TwoWirePlus_txRingBuffer.head] = 0xaa;
TwoWirePlus_incrementIndex(TwoWirePlus_txRingBuffer.head);
TwoWirePlus_txRingBuffer.lastOperation = TWOWIREPLUS_LASTOPERATION_WRITE;
TWI_vect();
TEST_ASSERT_EQUAL_INT(0xaa, TWDR);
TEST_ASSERT_EQUAL_INT((TWOWIREPLUS_BASETEST_TWCR_TWIE | TWOWIREPLUS_BASETEST_TWCR_TWEN | TWOWIREPLUS_BASETEST_TWCR_TWEA | TWOWIREPLUS_BASETEST_TWCR_TWINT), TWCR);
TwoWirePlus_BaseTest_resetBuffer();
TWSR = TW_REP_START;
TwoWirePlus_txRingBuffer.buffer[TwoWirePlus_txRingBuffer.head] = 0xaa;
TwoWirePlus_incrementIndex(TwoWirePlus_txRingBuffer.head);
TwoWirePlus_txRingBuffer.lastOperation = TWOWIREPLUS_LASTOPERATION_WRITE;
TWI_vect();
TEST_ASSERT_EQUAL_INT(0xaa, TWDR);
TEST_ASSERT_EQUAL_INT((TWOWIREPLUS_BASETEST_TWCR_TWIE | TWOWIREPLUS_BASETEST_TWCR_TWEN | TWOWIREPLUS_BASETEST_TWCR_TWEA | TWOWIREPLUS_BASETEST_TWCR_TWINT), TWCR);
}
static void test_pkt_count__1_elem(void)
{
gnrc_pktsnip_t snip1 = _INIT_ELEM_STATIC_DATA(TEST_STRING8, NULL);
TEST_ASSERT_EQUAL_INT(1, gnrc_pkt_count(&snip1));
}
static void test_ipv6_netif_add_addr__no_iface2(void)
{
TEST_ASSERT_EQUAL_INT(-ENOENT, ng_ipv6_netif_add_addr(DEFAULT_TEST_NETIF,
NULL, DEFAULT_TEST_PREFIX_LEN, false));
}
TEST(Stream, default_chunk_size_is_one)
{
TEST_ASSERT_EQUAL_INT(1, Stream_GetChunkSize(stream));
}
static void test_pktbuf_mark__success_small(void)
{
uint8_t *data = (uint8_t *)(TEST_STRING16);
gnrc_pktsnip_t *pkt1 = gnrc_pktbuf_add(NULL, data, sizeof(TEST_STRING16),
GNRC_NETTYPE_TEST);
gnrc_pktsnip_t *pkt2;
uint8_t exp_data1[sizeof(TEST_STRING16) - 1];
uint8_t exp_data2[1];
memcpy(exp_data1, data + sizeof(exp_data2), sizeof(exp_data1));
memcpy(exp_data2, data, sizeof(exp_data2));
TEST_ASSERT_NOT_NULL(pkt1);
TEST_ASSERT_NOT_NULL((pkt2 = gnrc_pktbuf_mark(pkt1, 1, GNRC_NETTYPE_UNDEF)));
TEST_ASSERT(gnrc_pktbuf_is_sane());
TEST_ASSERT(pkt1->next == pkt2);
TEST_ASSERT_NOT_NULL(pkt1->data);
TEST_ASSERT_EQUAL_INT(0, memcmp(exp_data1, pkt1->data, pkt1->size));
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING16) - 1, pkt1->size);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, pkt1->type);
TEST_ASSERT_EQUAL_INT(1, pkt1->users);
TEST_ASSERT_NULL(pkt2->next);
TEST_ASSERT_NOT_NULL(pkt2->data);
TEST_ASSERT_EQUAL_INT(0, memcmp(exp_data2, pkt2->data, pkt2->size));
TEST_ASSERT_EQUAL_INT(1, pkt2->size);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_UNDEF, pkt2->type);
TEST_ASSERT_EQUAL_INT(1, pkt2->users);
/* check if slightly larger packet would override data */
gnrc_pktbuf_remove_snip(pkt1, pkt2);
pkt2 = gnrc_pktbuf_add(NULL, TEST_STRING12, 3, GNRC_NETTYPE_TEST);
TEST_ASSERT(gnrc_pktbuf_is_sane());
TEST_ASSERT_NOT_NULL(pkt1->data);
TEST_ASSERT_EQUAL_INT(0, memcmp(exp_data1, pkt1->data, pkt1->size));
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING16) - 1, pkt1->size);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, pkt1->type);
TEST_ASSERT_EQUAL_INT(1, pkt1->users);
/* check if everything can be cleaned up */
gnrc_pktbuf_release(pkt1);
gnrc_pktbuf_release(pkt2);
TEST_ASSERT(gnrc_pktbuf_is_empty());
}
TEST(Stream, chunk_size_can_be_changed)
{
Stream_SetChunkSize(stream, 3);
TEST_ASSERT_EQUAL_INT(3, Stream_GetChunkSize(stream));
}
/**
* Request a few bytes from two wire slave device. Make slave device
* ACK his address. This test tests a typical two wire slave device
* read.
*/
static void TwoWirePlus_BaseTest_MasterReceiver_TC1(void)
{
TwoWirePlus_BaseTest_resetBuffer();
/* Start reading from address 0x42 four bytes */
Wire.beginReception(0x42);
/* Test if address SLA+R was written to txRingBuffer and that START was requested in TWCR */
TEST_ASSERT_EQUAL_INT(TWOWIREPLUS_LASTOPERATION_WRITE, TwoWirePlus_txRingBuffer.lastOperation);
TEST_ASSERT_EQUAL_INT(((0x42 << 1) | 0x01), TwoWirePlus_txRingBuffer.buffer[TwoWirePlus_BaseTest_previousElement(TwoWirePlus_txRingBuffer.head)]);
TEST_ASSERT_EQUAL_INT((TWOWIREPLUS_TWCR_START), TWCR);
/* Request four bytes and see if they are requested */
Wire.requestBytes(4);
TEST_ASSERT_EQUAL_INT(0x4, TwoWirePlus_bytesToReceive);
/* Emulate START was generated */
TWSR = TW_START;
TWI_vect();
/* Check if global TwoWirePlus_status was set correctly to START */
TEST_ASSERT_EQUAL_INT((TW_START), TwoWirePlus_status);
/* Preset TwoWirePlus_status register to emulate ACK for address from two wire slave device */
TWSR = TW_MR_SLA_ACK;
TWI_vect();
/* Test if TwoWirePlus_status is set correctly and SLA+R was read from txRingBuffer and written to tw data register */
TEST_ASSERT_EQUAL_INT((TW_MR_SLA_ACK), TwoWirePlus_status);
TEST_ASSERT_EQUAL_INT(TWOWIREPLUS_LASTOPERATION_READ, TwoWirePlus_txRingBuffer.lastOperation);
TEST_ASSERT_EQUAL_INT(((0x42 << 1) | 0x01), TWDR);
/* Test if txRingBuffer is empty now because address was sent. */
TEST_ASSERT(TwoWirePlus_RingBufferEmpty(TwoWirePlus_txRingBuffer));
/* Check if TWIE, TWEN, TWEA and TWINT were set in ISR. */
TEST_ASSERT_EQUAL_INT((TWOWIREPLUS_BASETEST_TWCR_TWIE | TWOWIREPLUS_BASETEST_TWCR_TWEN | TWOWIREPLUS_BASETEST_TWCR_TWEA | TWOWIREPLUS_BASETEST_TWCR_TWINT), TWCR);
/* Now signal three bytes to be received from two wire slave device. Test if TWCR is set
* correctly to make sure ACK and not NACK was sent. */
TWSR = TW_MR_DATA_ACK;
TWDR = 0xa1;
TWI_vect();
TEST_ASSERT_EQUAL_INT((TW_MR_DATA_ACK), TwoWirePlus_status);
TEST_ASSERT_EQUAL_INT((TWOWIREPLUS_BASETEST_TWCR_TWIE | TWOWIREPLUS_BASETEST_TWCR_TWEN | TWOWIREPLUS_BASETEST_TWCR_TWEA | TWOWIREPLUS_BASETEST_TWCR_TWINT), TWCR);
TWDR = 0xa2;
TWI_vect();
TEST_ASSERT_EQUAL_INT((TWOWIREPLUS_BASETEST_TWCR_TWIE | TWOWIREPLUS_BASETEST_TWCR_TWEN | TWOWIREPLUS_BASETEST_TWCR_TWEA | TWOWIREPLUS_BASETEST_TWCR_TWINT), TWCR);
TWDR = 0xa3;
TWI_vect();
/* For the very last by a NACK shall be sent TWEA = 0 */
TEST_ASSERT_EQUAL_INT((TWOWIREPLUS_BASETEST_TWCR_TWIE | TWOWIREPLUS_BASETEST_TWCR_TWEN | TWOWIREPLUS_BASETEST_TWCR_TWINT), TWCR);
/* Signal last byte and test if NACH (TWEA not set) is returned to two wire slave device */
TWDR = 0xa4;
TWI_vect();
TEST_ASSERT_EQUAL_INT((TWOWIREPLUS_BASETEST_TWCR_TWEN | TWOWIREPLUS_BASETEST_TWCR_TWEA ), TWCR);
/* Test if we really received four bytes and if the values match */
TEST_ASSERT_EQUAL_INT(4, Wire.available());
TEST_ASSERT_EQUAL_INT(0xa1, Wire.read());
TEST_ASSERT_EQUAL_INT(3, Wire.available());
TEST_ASSERT_EQUAL_INT(0xa2, Wire.read());
TEST_ASSERT_EQUAL_INT(2, Wire.available());
TEST_ASSERT_EQUAL_INT(0xa3, Wire.read());
TEST_ASSERT_EQUAL_INT(1, Wire.available());
TEST_ASSERT_EQUAL_INT(0xa4, Wire.read());
TEST_ASSERT_EQUAL_INT(0, Wire.available());
/* Wire.endReception can't be tested. A bit is set in this function and function will wait until bit is cleared in ISR */
}
static void testInit(void)
{
TEST_ASSERT_EQUAL_INT(0, Counter_value(counterRef));
}
