void gt_comm_wait_thread() {
char _key[11] = { };
char _value[128] = { };
int expected_key = 1;
greentea_send_kv("timing_drift_check_start", 0);
// wait for 1st signal from host
do {
greentea_parse_kv(_key, _value, sizeof(_key), sizeof(_value));
expected_key = strcmp(_key, "base_time");
} while (expected_key);
greentea_send_kv(_key, callback_trigger_count * ONE_MILLI_SEC);
// wait for 2nd signal from host
greentea_parse_kv(_key, _value, sizeof(_key), sizeof(_value));
greentea_send_kv(_key, callback_trigger_count * ONE_MILLI_SEC);
//get the results from host
greentea_parse_kv(_key, _value, sizeof(_key), sizeof(_value));
if (strcmp("pass", _key) == 0) {
test_result = true;
}
}
int main() {
GREENTEA_SETUP(20, "udp_echo");
EthernetInterface eth;
eth.connect();
printf("UDP client IP Address is %s\n", eth.get_ip_address());
greentea_send_kv("target_ip", eth.get_ip_address());
char recv_key[] = "host_port";
char ipbuf[60] = {0};
char portbuf[16] = {0};
unsigned int port = 0;
UDPSocket sock;
sock.open(ð);
sock.set_timeout(MBED_CFG_UDP_CLIENT_ECHO_TIMEOUT);
greentea_send_kv("host_ip", " ");
greentea_parse_kv(recv_key, ipbuf, sizeof(recv_key), sizeof(ipbuf));
greentea_send_kv("host_port", " ");
greentea_parse_kv(recv_key, portbuf, sizeof(recv_key), sizeof(ipbuf));
sscanf(portbuf, "%u", &port);
printf("MBED: UDP Server IP address received: %s:%d \n", ipbuf, port);
SocketAddress udp_addr(ipbuf, port);
int success = 0;
for (int i=0; i < ECHO_LOOPS; ++i) {
prep_buffer(tx_buffer, sizeof(tx_buffer));
const int ret = sock.sendto(udp_addr, tx_buffer, sizeof(tx_buffer));
printf("[%02d] sent...%d Bytes \n", i, ret);
SocketAddress temp_addr;
const int n = sock.recvfrom(&temp_addr, rx_buffer, sizeof(rx_buffer));
printf("[%02d] recv...%d Bytes \n", i, n);
if ((temp_addr == udp_addr &&
n == sizeof(tx_buffer) &&
memcmp(rx_buffer, tx_buffer, sizeof(rx_buffer)) == 0)) {
success += 1;
}
}
bool result = (success > 3*ECHO_LOOPS/4);
sock.close();
eth.disconnect();
GREENTEA_TESTSUITE_RESULT(result);
}
int main() {
GREENTEA_SETUP(20, "tcp_echo_client");
EthernetInterface eth;
eth.connect();
printf("MBED: TCPClient IP address is '%s'\n", eth.get_ip_address());
printf("MBED: TCPClient waiting for server IP and port...\n");
greentea_send_kv("target_ip", eth.get_ip_address());
bool result = false;
char recv_key[] = "host_port";
char ipbuf[60] = {0};
char portbuf[16] = {0};
unsigned int port = 0;
greentea_send_kv("host_ip", " ");
greentea_parse_kv(recv_key, ipbuf, sizeof(recv_key), sizeof(ipbuf));
greentea_send_kv("host_port", " ");
greentea_parse_kv(recv_key, portbuf, sizeof(recv_key), sizeof(ipbuf));
sscanf(portbuf, "%u", &port);
printf("MBED: Server IP address received: %s:%d \n", ipbuf, port);
TCPSocket sock(ð);
SocketAddress tcp_addr(ipbuf, port);
if (sock.connect(tcp_addr) == 0) {
printf("HTTP: Connected to %s:%d\r\n", ipbuf, port);
printf("tx_buffer buffer size: %u\r\n", sizeof(tx_buffer));
printf("rx_buffer buffer size: %u\r\n", sizeof(rx_buffer));
prep_buffer(tx_buffer, sizeof(tx_buffer));
sock.send(tx_buffer, sizeof(tx_buffer));
// Server will respond with HTTP GET's success code
const int ret = sock.recv(rx_buffer, sizeof(rx_buffer));
result = !memcmp(tx_buffer, rx_buffer, sizeof(tx_buffer));
TEST_ASSERT_EQUAL(ret, sizeof(rx_buffer));
TEST_ASSERT_EQUAL(true, result);
}
sock.close();
eth.disconnect();
GREENTEA_TESTSUITE_RESULT(result);
}
int main() {
GREENTEA_SETUP(20, "udp_echo_client");
EthernetInterface eth;
eth.connect();
printf("UDP client IP Address is %s\n", eth.get_ip_address());
greentea_send_kv("target_ip", eth.get_ip_address());
bool result = true;
char recv_key[] = "host_port";
char ipbuf[60] = {0};
char portbuf[16] = {0};
unsigned int port = 0;
UDPSocket sock;
sock.open(ð);
greentea_send_kv("host_ip", " ");
greentea_parse_kv(recv_key, ipbuf, sizeof(recv_key), sizeof(ipbuf));
greentea_send_kv("host_port", " ");
greentea_parse_kv(recv_key, portbuf, sizeof(recv_key), sizeof(ipbuf));
sscanf(portbuf, "%u", &port);
printf("MBED: UDP Server IP address received: %s:%d \n", ipbuf, port);
SocketAddress addr(ipbuf, port);
for (int i=0; i < ECHO_LOOPS; ++i) {
prep_buffer(tx_buffer, sizeof(tx_buffer));
const int ret = sock.sendto(addr, tx_buffer, sizeof(tx_buffer));
printf("[%02d] sent...%d Bytes \n", i, ret);
const int n = sock.recvfrom(&addr, rx_buffer, sizeof(rx_buffer));
printf("[%02d] recv...%d Bytes \n", i, n);
if (memcmp(rx_buffer, tx_buffer, sizeof(rx_buffer))) {
result = false;
break;
}
}
sock.close();
eth.disconnect();
GREENTEA_TESTSUITE_RESULT(result);
}
/* Test that software reset doesn't stop RTC from counting. */
void rtc_reset_test()
{
GREENTEA_SETUP(100, "rtc_reset");
static char _key[10 + 1] = {};
static char _value[128 + 1] = {};
greentea_send_kv("start", 1);
// Handshake with host
cmd_status_t cmd_status = CMD_STATUS_CONTINUE;
while (CMD_STATUS_CONTINUE == cmd_status) {
memset(_key, 0, sizeof(_key));
memset(_value, 0, sizeof(_value));
greentea_parse_kv(_key, _value, sizeof(_key) - 1, sizeof(_value) - 1);
cmd_status = handle_command(_key, _value);
}
GREENTEA_TESTSUITE_RESULT(CMD_STATUS_PASS == cmd_status);
}
/** \brief Handshake with host and send setup data (timeout and host test name)
* \details This function will send preamble to master.
* After host test name is received master will invoke host test script
* and add hos test's callback handlers to main event loop
* This function is blocking.
*/
void GREENTEA_SETUP(const int timeout, const char *host_test_name) {
greentea_metrics_setup();
// Key-value protocol handshake function. Waits for {{__sync;...}} message
// Sync preamble: "{{__sync;0dad4a9d-59a3-4aec-810d-d5fb09d852c1}}"
// Example value of sync_uuid == "0dad4a9d-59a3-4aec-810d-d5fb09d852c1"
char _key[8] = {0};
char _value[48] = {0};
while (1) {
greentea_parse_kv(_key, _value, sizeof(_key), sizeof(_value));
greentea_write_string("mbedmbedmbedmbedmbedmbedmbedmbed\r\n");
if (strcmp(_key, GREENTEA_TEST_ENV_SYNC) == 0) {
// Found correct __sunc message
greentea_send_kv(_key, _value);
break;
}
}
greentea_notify_version();
greentea_notify_timeout(timeout);
greentea_notify_hosttest(host_test_name);
}
int main() {
GREENTEA_SETUP(20, "udp_shotgun");
EthernetInterface eth;
int err = eth.connect();
TEST_ASSERT_EQUAL(0, err);
printf("MBED: UDPClient IP address is '%s'\n", eth.get_ip_address());
printf("MBED: UDPClient waiting for server IP and port...\n");
greentea_send_kv("target_ip", eth.get_ip_address());
bool result = false;
char recv_key[] = "host_port";
char ipbuf[60] = {0};
char portbuf[16] = {0};
unsigned int port = 0;
greentea_send_kv("host_ip", " ");
greentea_parse_kv(recv_key, ipbuf, sizeof(recv_key), sizeof(ipbuf));
greentea_send_kv("host_port", " ");
greentea_parse_kv(recv_key, portbuf, sizeof(recv_key), sizeof(ipbuf));
sscanf(portbuf, "%u", &port);
printf("MBED: UDP Server IP address received: %s:%d \n", ipbuf, port);
// align each size to 4-bits
for (int i = 0; i < udp_dtls_handshake_count; i++) {
udp_dtls_handshake_pattern[i] = (~0xf & udp_dtls_handshake_pattern[i]) + 0x10;
}
printf("MBED: DTLS pattern [");
for (int i = 0; i < udp_dtls_handshake_count; i++) {
printf("%d", udp_dtls_handshake_pattern[i]);
if (i != udp_dtls_handshake_count-1) {
printf(", ");
}
}
printf("]\r\n");
UDPSocket sock;
SocketAddress udp_addr(ipbuf, port);
for (int attempt = 0; attempt < MBED_CFG_UDP_DTLS_HANDSHAKE_RETRIES; attempt++) {
err = sock.open(ð);
TEST_ASSERT_EQUAL(0, err);
for (int i = 0; i < udp_dtls_handshake_count; i++) {
buffer[i] = udp_dtls_handshake_pattern[i] >> 4;
}
err = sock.sendto(udp_addr, buffer, udp_dtls_handshake_count);
printf("UDP: tx -> %d\r\n", err);
TEST_ASSERT_EQUAL(udp_dtls_handshake_count, err);
int step = 0;
while (step < udp_dtls_handshake_count) {
err = sock.recvfrom(NULL, buffer, sizeof(buffer));
printf("UDP: rx <- %d ", err);
// check length
if (err != udp_dtls_handshake_pattern[step]) {
printf("x (expected %d)\r\n", udp_dtls_handshake_pattern[step]);
break;
}
// check quick xor of packet
uint8_t check = 0;
for (int j = 0; j < udp_dtls_handshake_pattern[step]; j++) {
check ^= buffer[j];
}
if (check != 0) {
printf("x (checksum 0x%02x)\r\n", check);
break;
}
// successfully got a packet
printf("\r\n");
step += 1;
}
err = sock.close();
TEST_ASSERT_EQUAL(0, err);
// got through all steps, test passed
if (step == udp_dtls_handshake_count) {
result = true;
break;
}
}
eth.disconnect();
GREENTEA_TESTSUITE_RESULT(result);
}
