Revision 10:0d938ec9100c, committed 2016-04-21

Comitter:

Christopher Haster

Date:

Thu Apr 21 01:54:51 2016 -0500

Parent:

9:07b22947be75

Child:

11:fbfe3498404a

Commit message:

Updated NSAPITests to match changes in the NSAPI

- separated tests to tcp/udp tests
- added appropriate open/close tests
- added flushing behaviour to take care of garbage
- increased test size to 2048 bytes

Changed in this revision

--- a/NSAPITests.cpp	Thu Mar 03 21:04:29 2016 +0000
+++ b/NSAPITests.cpp	Thu Apr 21 01:54:51 2016 -0500
@@ -1,323 +1,435 @@
-#include "NetworkInterface.h"
+#include "NetworkStack.h"
 #include "TCPSocket.h"
 #include "UDPSocket.h"
 #include <stdio.h>
 #include "string.h"
 
-#define NSAPI_MAX_DATA_SIZE 500
-
-char expected_data[NSAPI_MAX_DATA_SIZE];
-char received_data[NSAPI_MAX_DATA_SIZE];
+#define NSAPI_MAX_DATA_SIZE 2048
+#define NSAPI_TEST_HOST "mbed.org"
+#define NSAPI_TEST_IP   "8.8.4.4"
 
-int nsapi_ni_isConnected_test(NetworkInterface *iface)
-{
-  return !(iface->isConnected());
-}
-
-int nsapi_ni_getIPAddress_test(NetworkInterface *iface)
-{
+uint8_t test_buffer[NSAPI_MAX_DATA_SIZE];
 
-  if (!iface->getIPAddress()[0]) {
-    printf("'getIpAddress' did not return an IP address\r\n");
-    return -1;
-  }
-
-  return 0;
-}
+int nsapi_networkstack_get_ip_address_test(NetworkStack *stack)
+{
+    if (!stack->get_ip_address()[0]) {
+        printf("error: 'get_ip_address()' did not return an IP address\r\n");
+        return -1;
+    }
 
-int nsapi_ni_getMACAddress_test(NetworkInterface *iface)
-{
-
-  if (!iface->getMACAddress()[0]) {
-    printf("'getMacAddress' did not return a MAC address\r\n");
-    return -1;
-  }
-
-  return 0;
+    return 0;
 }
 
-int nsapi_ni_getHostByName_test(NetworkInterface *iface)
+int nsapi_networkstack_gethostbyname_test(NetworkStack *stack, SocketAddress *address, const char *test_host)
 {
-  char ip_address[NS_IP_SIZE] = "\0";
+    int ret = stack->gethostbyname(address, NSAPI_TEST_HOST);
 
-  int32_t ret = iface->getHostByName("developer.mbed.org", ip_address);
+    if (ret) {
+        printf("error: 'gethostbyname(\"%s\")' failed with code %d\r\n", NSAPI_TEST_HOST, ret);
+        return -1;
+    } else if (!address) {
+        printf("error: 'gethostbyname(\"%s\")' returned null IP address\r\n", NSAPI_TEST_HOST);
+        return -2;
+    }
+
+    ret = stack->gethostbyname(address, NSAPI_TEST_IP);
 
-  if (ret) {
-    printf("'getHostByName' failed with code %d\r\n", ret);
-    return -1;
-  } else if (!ip_address[0]) {
-    printf("Returned IP address was null\r\n");
-    return -2;
-  } else {
+    if (ret) {
+        printf("error: 'gethostbyname(\"%s\")' failed with code %d\r\n", NSAPI_TEST_IP, ret);
+        return -1;
+    } else if (!address) {
+        printf("error: 'gethostbyname(\"%s\")' returned null IP address\r\n", NSAPI_TEST_IP);
+        return -2;
+    }
+
+    ret = stack->gethostbyname(address, test_host);
+
+    if (ret) {
+        printf("error: 'gethostbyname(\"%s\")' failed with code %d\r\n", test_host, ret);
+        return -1;
+    } else if (!address) {
+        printf("error: 'gethostbyname(\"%s\")' returned null IP address\r\n", test_host);
+        return -2;
+    }
+
     return 0;
-  }
+}
+
+static void nsapi_buffer_init(uint8_t *buffer, unsigned size)
+{
+    for (unsigned i = 0; i < size; i++) {
+        buffer[i] = '0' + (i % 10);
+    }
 }
 
-int nsapi_socket_open_test(Socket *socket, const char *test_address, uint16_t test_port)
+static bool nsapi_buffer_check(const uint8_t *buffer, unsigned size)
 {
-  int32_t ret = socket->open(test_address, test_port);
+    for (unsigned i = 0; i < size; i++) {
+        if (buffer[i] != '0' + (i % 10)) {
+            return false;
+        }
+    }
 
-  if (ret) {
-    printf("'open' failed with code %d\r\n", ret);
-    return -1;
-  } else {
-    return 0;
-  }
+    return true;
+}
+
+static void nsapi_tcp_flush(TCPSocket *socket)
+{
+    socket->set_timeout(1000);
+    socket->recv(test_buffer, sizeof test_buffer);
+    socket->set_timeout(-1);
 }
 
-int nsapi_socket_isConnected_test(Socket *socket, const char *test_address, uint16_t test_port)
+int nsapi_tcp_open_test(TCPSocket *udp, NetworkStack *stack)
 {
-  return !socket->isConnected();
+    int ret = udp->open(stack);
+
+    if (ret) {
+        printf("error: 'open(%p)' failed with code %d\r\n", stack, ret);
+        return -1;
+    } else {
+        return 0;
+    }
+}
+
+int nsapi_tcp_connect_test(TCPSocket *tcp, SocketAddress *addr)
+{
+    int ret = tcp->connect(*addr);
+
+    if (ret) {
+        printf("error: 'connect(SocketAddress(%s, %d))' failed with code %d\r\n",
+                addr->get_ip_address(), addr->get_port(), ret);
+        return -1;
+    } else {
+        return 0;
+    }
 }
 
+static int nsapi_tcp_blocking_test_helper(TCPSocket *tcp, unsigned size)
+{
+    unsigned total;
+    nsapi_tcp_flush(tcp);
+    nsapi_buffer_init(test_buffer, size);
 
-int nsapi_socket_getIpAddress_test(Socket *socket, const char *test_address, uint16_t test_port)
-{
-  const char *cur_ip_address = socket->getIPAddress();
+    for (total = 0; total < size;) {
+        int ret = tcp->send(test_buffer, size);
+
+        if (ret < 0) {
+            printf("error: 'send(buffer, %d)' failed during test with code %d\r\n", size, ret);
+            return -1;
+        }
+
+        total += ret;
+    }
 
-  if (!cur_ip_address[0]) {
-    printf("'getIpAddress' did not return an IP address\r\n");
-    return -1;
-  } else if (strcmp(cur_ip_address, test_address)) {
-    printf("'getIpAddress' did not reutrurn the expected IP address\r\n");
-    printf("Expected: %s\r\n", test_address);
-    printf("Actual: %s\r\n", cur_ip_address);
-    return -2;
-  }
+    for (total = 0; total < size;) {
+        int ret = tcp->recv(test_buffer, sizeof test_buffer);
+
+        if (ret < 0) {
+            printf("error: 'recv(buffer, %d)' failed during test with code %d\r\n", sizeof test_buffer, ret);
+            return -2;
+        }
 
-  return 0;
+        total += ret;
+    }
+
+    if (total != size || !nsapi_buffer_check(test_buffer, size)) {
+        printf("error: 'recv(buffer, %d)' recieved incorrect data with length %d\r\n", sizeof test_buffer, total);
+        return -3;
+    }
+
+    return 0;
 }
 
-int nsapi_socket_getPort_test(Socket *socket, const char *test_address, uint16_t test_port)
+int nsapi_tcp_blocking_test(TCPSocket *tcp)
 {
-  uint16_t cur_port = socket->getPort();
+    for (unsigned size = 64; size <= NSAPI_MAX_DATA_SIZE; size *= 2) {
+        printf("%s: size %d\r\n", __func__, size);
 
-  if (cur_port != test_port) {
-    printf("'getPort' did not return the expected port\r\n");
-    printf("Expected: %d\r\n", test_port);
-    printf("Actual: %d\r\n", cur_port);
-    return -1;
-  }
+        int ret = nsapi_tcp_blocking_test_helper(tcp, size);
+        if (ret) {
+            return ret;
+        }
+    }
 
-  return 0;
-}
-
-void nsapi_socket_test_setup(char *buffer, int size)
-{
-  int i;
-  for (i = 0; i < size; i++) {
-    buffer[i] = '0' + (i % 10);
-  }
+    return 0;
 }
 
-int nsapi_socket_blocking_test_helper(Socket *socket, const char *test_address, uint16_t test_port, uint32_t data_size)
+static int nsapi_tcp_non_blocking_test_helper(TCPSocket *tcp, unsigned size)
 {
-  nsapi_socket_test_setup(expected_data, data_size);
-
-  int32_t ret = socket->send(expected_data, data_size);
+    unsigned total;
+    nsapi_tcp_flush(tcp);
+    nsapi_buffer_init(test_buffer, size);
 
-  if (ret) {
-    printf("'send' failed during test with code %d\r\n", ret);
-    return -4;
-  }
-
-  int32_t bytes_received = socket->recv(received_data, sizeof(received_data));
+    // First check to make sure `recv` will not block and return 0 for bytes received.
+    tcp->set_blocking(false);
+    int ret = tcp->recv(test_buffer, sizeof test_buffer);
 
-  if (bytes_received >= (int32_t)data_size) {
-    if (memcmp(received_data, expected_data, data_size) == 0) {
-      return 0;
-    } else {
-      printf("'recv' returned incorrect data with length %d\r\n", bytes_received);
-      return -2;
+    if (ret != NSAPI_ERROR_WOULD_BLOCK) {
+        if (ret < 0) {
+            printf("error: 'recv(buffer, %d)' failed during test with code %d\r\n", sizeof test_buffer, ret);
+            return -4;
+        } else {
+            printf("error: 'recv(buffer, %d)' returned %d when no data was expected\r\n", sizeof test_buffer, ret);
+            return -5;
+        }
     }
-  } else if (bytes_received < 0) {
-    printf("'recv' failed with code %d\r\n", bytes_received);
-    return -3;
-  } else {
-    printf("'recv' returned no data\r\n");
-    return -1;
-  }
-}
+
+    for (total = 0; total < size;) {
+        int ret = tcp->send(test_buffer, size);
 
-int nsapi_socket_blocking_test(Socket *socket, const char *test_address, uint16_t test_port)
-{
-  int32_t result, i;
-  int32_t packet_sizes[] = {10, 100, 500};
-  int32_t num_packet_sizes = 3;
+        if (ret < 0) {
+            printf("error: 'send(buffer, %d)' failed during test with code %d\r\n", size, ret);
+            return -1;
+        }
+
+        total += ret;
+    }
+
+ 
+    for (total = 0; total < size;) {
+        ret = tcp->recv(test_buffer, sizeof test_buffer);
 
-  for (i = 0; i < num_packet_sizes; i++) {
-    result = nsapi_socket_blocking_test_helper(socket, test_address, test_port, packet_sizes[i]);
-
-    if (result) {
-      printf("nsapi_socket_blocking_test failed with data size %d\r\n", packet_sizes[i]);
-      break;
+        if (ret == NSAPI_ERROR_WOULD_BLOCK) {
+            continue;
+        } else if (ret < 0) {
+            printf("error: 'recv(buffer, %d)' failed during test with code %d\r\n", sizeof test_buffer, ret);
+            return -2;
+        } else {
+            total += ret;
+        }
     }
-  }
 
-  if (i >= num_packet_sizes) {
+    if (total != size || !nsapi_buffer_check(test_buffer, size)) {
+        printf("error: 'recv(buffer, %d)' recieved incorrect data with length %d\r\n", sizeof test_buffer, total);
+        return -3;
+    }
+    
     return 0;
-  } else {
-    return -num_packet_sizes;
-  }
 }
 
-int nsapi_socket_non_blocking_test_helper(Socket *socket, const char *test_address, uint16_t test_port, uint32_t data_size)
+int nsapi_tcp_non_blocking_test(TCPSocket *tcp)
 {
-  int32_t bytes_received;
-  int result = -1;
-
-  nsapi_socket_test_setup(expected_data, data_size);
-
-  // First check to make sure `recv` will not block and return 0 for bytes
-  // received. If the tests do proceed after this test, be sure your `recv`
-  // respects the `blocking` flag
-  bytes_received = socket->recv(received_data, NSAPI_MAX_DATA_SIZE, false);
+    for (unsigned size = 64; size <= NSAPI_MAX_DATA_SIZE; size *= 2) {
+        printf("%s: size %d\r\n", __func__, size);
 
-  if (bytes_received > 0) {
-    printf("'recv' returned data of length %d when no data was expected\r\n", bytes_received);
-    return -5;
-  } else if (bytes_received < 0) {
-    printf("'recv' failed when no data was expected with code %d\r\n", bytes_received);
-    return -5;
-  }
+        int ret = nsapi_tcp_non_blocking_test_helper(tcp, size);
+        if (ret) {
+            return ret;
+        }
+    }
 
-  int32_t ret = socket->send(expected_data, data_size);
+    return 0;
+}
 
-  if (ret) {
-    printf("'send' failed during test with code %d\r\n", ret);
-    return -4;
-  }
+int nsapi_tcp_close_test(TCPSocket *tcp)
+{
+    int ret = tcp->close();
 
-  // TODO: Create a better way to "wait" for data besides busy-looping
-  for (int i = 0; i < 10000000; i++) {
-    bytes_received = socket->recv(received_data, data_size, false);
+    if (ret) {
+        printf("error 'close()' failed with code %d\r\n", ret);
+        return -1;
+    } else {
+        return 0;
+    }
+}
 
-    if (bytes_received >= (int32_t)data_size) {
-      if (memcmp(received_data, expected_data, data_size) == 0) {
-        result = 0;
-        break;
-      } else {
-        result =  -2;
-        break;
-      }
-    } else if (bytes_received < 0) {
-      result = -3;
-      break;
+static void nsapi_udp_flush(UDPSocket *udp)
+{
+    udp->set_timeout(1000);
+    udp->recvfrom(0, test_buffer, sizeof test_buffer);
+    udp->set_timeout(-1);
+}
+
+int nsapi_udp_open_test(UDPSocket *udp, NetworkStack *stack)
+{
+    int ret = udp->open(stack);
+
+    if (ret) {
+        printf("error: 'open(%p)' failed with code %d\r\n", stack, ret);
+        return -1;
+    } else {
+        return 0;
     }
-  }
-
-  if (result == -1) {
-    printf("'recv' returned no data\r\n");
-  } else if (result == -2) {
-    printf("'recv' returned incorrect data with length %d\r\n", bytes_received);
-  } else if (result == -3) {
-    printf("'recv' failed with code %d\r\n", bytes_received);
-  }
-
-  return result;
 }
 
-int nsapi_socket_non_blocking_test(Socket *socket, const char *test_address, uint16_t test_port)
+static int nsapi_udp_blocking_test_helper(UDPSocket *udp, SocketAddress *addr, unsigned size)
 {
-  int32_t result, i;
-  int32_t packet_sizes[] = {10, 100, 500};
-  int32_t num_packet_sizes = 3;
+    unsigned total;
+    nsapi_udp_flush(udp);
+    nsapi_buffer_init(test_buffer, size);
+
+    for (total = 0; total < size;) {
+        int ret = udp->sendto(*addr, test_buffer, size);
 
-  for (i = 0; i < num_packet_sizes; i++) {
-    result = nsapi_socket_non_blocking_test_helper(socket, test_address, test_port, packet_sizes[i]);
+        if (ret < 0) {
+            printf("error: 'sendto(SocketAddress(%s, %d), buffer, %d)' failed during test with code %d\r\n", 
+                    addr->get_ip_address(), addr->get_port(), size, ret);
+            return -1;
+        }
+
+        total += ret;
+    }
+
+    for (total = 0; total < size;) {
+        int ret = udp->recvfrom(0, test_buffer, sizeof test_buffer);
 
-    if (result) {
-      printf("nsapi_socket_non_blocking_test failed with data size of %d\r\n", packet_sizes[i]);
-      break;
+        if (ret < 0) {
+            printf("error: 'recvfrom(0, buffer, %d)' failed during test with code %d\r\n", sizeof test_buffer, ret);
+            return -2;
+        }
+
+        total += ret;
     }
-  }
+
+    if (total != size || !nsapi_buffer_check(test_buffer, size)) {
+        printf("error: 'recvfrom(0, buffer, %d)' recieved incorrect data with length %d\r\n", sizeof test_buffer, total);
+        return -3;
+    }
 
-  if (i >= num_packet_sizes) {
     return 0;
-  } else {
-    return -num_packet_sizes;
-  }
+}
+
+int nsapi_udp_blocking_test(UDPSocket *udp, SocketAddress *addr)
+{
+    for (unsigned size = 64; size <= NSAPI_MAX_DATA_SIZE; size *= 2) {
+        printf("%s: size %d\r\n", __func__, size);
+
+        int ret = nsapi_udp_blocking_test_helper(udp, addr, size);
+        if (ret) {
+            return ret;
+        }
+    }
+
+    return 0;
 }
 
-int nsapi_socket_close_test(Socket *socket, const char *test_address, uint16_t test_port)
+int nsapi_udp_non_blocking_test_helper(UDPSocket *udp, SocketAddress *addr, unsigned size)
 {
-  int32_t ret = socket->close();
+    unsigned total;
+    nsapi_udp_flush(udp);
+    nsapi_buffer_init(test_buffer, size);
+
+    // First check to make sure `recv` will not block and return 0 for bytes received.
+    udp->set_blocking(false);
+    int ret = udp->recvfrom(0, test_buffer, sizeof test_buffer);
 
-  if (ret) {
-    printf("'close' failed with code %d\r\n", ret);
-    return -1;
-  } else {
-    return 0;
-  }
-}
+    if (ret != NSAPI_ERROR_WOULD_BLOCK) {
+        if (ret < 0) {
+            printf("error: 'recvfrom(0, buffer, %d)' failed during test with code %d\r\n", sizeof test_buffer, ret);
+            return -4;
+        } else {
+            printf("error: 'recvfrom(0, buffer, %d)' returned %d when no data was expected\r\n", sizeof test_buffer, ret);
+            return -5;
+        }
+    }
 
-void nspai_print_test_header(const char *name) {
-  printf("---------------------\r\n");
-  printf("%s: running...\r\n", name);
-}
+    for (total = 0; total < size;) {
+        int ret = udp->sendto(*addr, test_buffer, size);
 
-void nspai_print_test_result(const char *name, int result) {
-  printf("%s: ", name);
+        if (ret < 0) {
+            printf("error: 'sendto(SocketAddress(%s, %d), buffer, %d)' failed during test with code %d\r\n", 
+                    addr->get_ip_address(), addr->get_port(), size, ret);
+            return -1;
+        }
+
+        total += ret;
+    }
+ 
+    for (total = 0; total < size;) {
+        ret = udp->recvfrom(0, test_buffer, sizeof test_buffer);
 
-  if (!result) {
-    printf("PASS\r\n");
-  } else {
-    printf("FAIL (Return code %d)\r\n", result);
-  }
-}
+        if (ret == NSAPI_ERROR_WOULD_BLOCK) {
+            continue;
+        } else if (ret < 0) {
+            printf("error: 'recv(buffer, %d)' failed during test with code %d\r\n", sizeof test_buffer, ret);
+            return -2;
+        } else {
+            total += ret;
+        }
+    }
 
-int nsapi_ni_run_test(const char *name, NetworkInterface *iface, int (*test)(NetworkInterface*)) {
-  int result;
-  nspai_print_test_header(name);
-  result = test(iface);
-  nspai_print_test_result(name, result);
-  return result;
+    if (total != size || !nsapi_buffer_check(test_buffer, size)) {
+        printf("error: 'recv(buffer, %d)' recieved incorrect data with length %d\r\n", sizeof test_buffer, total);
+        return -3;
+    }
+    
+    return 0;
 }
 
-int nsapi_socket_run_test(const char *name, Socket *socket, const char *test_address, uint16_t test_port, int (*test)(Socket*, const char*, uint16_t)) {
-  int result;
-  nspai_print_test_header(name);
-  result = test(socket, test_address, test_port);
-  nspai_print_test_result(name, result);
-  return result;
+int nsapi_udp_non_blocking_test(UDPSocket *udp, SocketAddress *addr)
+{
+    for (unsigned size = 64; size <= NSAPI_MAX_DATA_SIZE; size *= 2) {
+        printf("%s: size %d\r\n", __func__, size);
+
+        int ret = nsapi_udp_non_blocking_test_helper(udp, addr, size);
+        if (ret) {
+            return ret;
+        }
+    }
+
+    return 0;
+}
+
+int nsapi_udp_close_test(UDPSocket *udp)
+{
+    int ret = udp->close();
+
+    if (ret) {
+        printf("error 'close()' failed with code %d\r\n", ret);
+        return -1;
+    } else {
+        return 0;
+    }
 }
 
-int nsapi_tests(const char *name, NetworkInterface *iface, const char *test_address, uint16_t test_port)
+int nsapi_tests(const char *name, NetworkStack *stack, const char *test_host, uint16_t test_port)
 {
-  TCPSocket tcp_socket(iface);
-  UDPSocket udp_socket(iface);
+    SocketAddress address(0, test_port);
+    TCPSocket tcp;
+    UDPSocket udp;
+
+    int result = 0;
+
+#define NSAPI_MARK_TESTS(tests)                                 \
+    printf("\r\n\r\nRunning %s Tests\r\n\r\n", tests)
 
-  int ret = 0;
-
-  printf("--- Running NetworkInterface Tests ---\r\n\r\n");
-  ret |= nsapi_ni_run_test("nsapi_ni_isConnected_test", iface, &nsapi_ni_isConnected_test);
-  ret |= nsapi_ni_run_test("nsapi_ni_getIPAddress_test", iface, &nsapi_ni_getIPAddress_test);
-  ret |= nsapi_ni_run_test("nsapi_ni_getMACAddress_test", iface, &nsapi_ni_getMACAddress_test);
-  ret |= nsapi_ni_run_test("nsapi_ni_getHostByName_test", iface, &nsapi_ni_getHostByName_test);
+#define NSAPI_RUN_TEST(test, ...)                               \
+    do {                                                        \
+        printf("---------------------\r\n");                    \
+        printf("%s: running...\r\n", #test);                    \
+        int test##_result = test(__VA_ARGS__);                  \
+        if (!test##_result) {                                   \
+            printf("%s: PASS\r\n", #test);                      \
+        } else {                                                \
+            printf("%s: FAIL (%d)\r\n", #test, test##_result);  \
+        }                                                       \
+        result |= test##_result;                                \
+    } while (0)
 
-  printf("\r\n\r\n--- Running TCPSocket Tests ---\r\n\r\n");
-  ret |= nsapi_socket_run_test("nsapi_socket_open_test", &tcp_socket, test_address, test_port, &nsapi_socket_open_test);
-  ret |= nsapi_socket_run_test("nsapi_socket_getIpAddress_test", &tcp_socket, test_address, test_port, &nsapi_socket_getIpAddress_test);
-  ret |= nsapi_socket_run_test("nsapi_socket_getPort_test", &tcp_socket, test_address, test_port, &nsapi_socket_getPort_test);
-  ret |= nsapi_socket_run_test("nsapi_socket_blocking_test", &tcp_socket, test_address, test_port, &nsapi_socket_blocking_test);
-  ret |= nsapi_socket_run_test("nsapi_socket_non_blocking_test", &tcp_socket, test_address, test_port, &nsapi_socket_non_blocking_test);
-  ret |= nsapi_socket_run_test("nsapi_socket_close_test", &tcp_socket, test_address, test_port, &nsapi_socket_close_test);
+    NSAPI_MARK_TESTS("NetworkStack");
+    NSAPI_RUN_TEST(nsapi_networkstack_get_ip_address_test, stack);
+    NSAPI_RUN_TEST(nsapi_networkstack_gethostbyname_test, stack, &address, test_host);
 
+    NSAPI_MARK_TESTS("UDPSocket");
+    NSAPI_RUN_TEST(nsapi_udp_open_test, &udp, stack);
+    NSAPI_RUN_TEST(nsapi_udp_blocking_test, &udp, &address);
+    NSAPI_RUN_TEST(nsapi_udp_non_blocking_test, &udp, &address);
+    NSAPI_RUN_TEST(nsapi_udp_close_test, &udp);
 
-  printf("\r\n\r\n--- Running UDPSocket Tests ---\r\n\r\n");
-  ret |= nsapi_socket_run_test("nsapi_socket_open_test", &udp_socket, test_address, test_port, &nsapi_socket_open_test);
-  ret |= nsapi_socket_run_test("nsapi_socket_getIpAddress_test", &udp_socket, test_address, test_port, &nsapi_socket_getIpAddress_test);
-  ret |= nsapi_socket_run_test("nsapi_socket_getPort_test", &udp_socket, test_address, test_port, &nsapi_socket_getPort_test);
-  ret |= nsapi_socket_run_test("nsapi_socket_blocking_test", &udp_socket, test_address, test_port, &nsapi_socket_blocking_test);
-  ret |= nsapi_socket_run_test("nsapi_socket_non_blocking_test", &udp_socket, test_address, test_port, &nsapi_socket_non_blocking_test);
-  ret |= nsapi_socket_run_test("nsapi_socket_close_test", &udp_socket, test_address, test_port, &nsapi_socket_close_test);
+    NSAPI_MARK_TESTS("TCPSocket");
+    NSAPI_RUN_TEST(nsapi_tcp_open_test, &tcp, stack);
+    NSAPI_RUN_TEST(nsapi_tcp_connect_test, &tcp, &address);
+    NSAPI_RUN_TEST(nsapi_tcp_blocking_test, &tcp);
+    NSAPI_RUN_TEST(nsapi_tcp_non_blocking_test, &tcp);
+    NSAPI_RUN_TEST(nsapi_tcp_close_test, &tcp);
 
-  if (ret == 0) {
-    printf("\r\n\r\n--- ALL TESTS PASSING ---\r\n");
-  } else {
-    printf("\r\n\r\n--- TEST FAILURES OCCURRED ---\r\n");
-  }
+    if (result == 0) {
+        printf("\r\n\r\n--- ALL TESTS PASSING ---\r\n");
+    } else {
+        printf("\r\n\r\n--- TEST FAILURES OCCURRED ---\r\n");
+    }
 
-  return ret != 0;
+    return result;
 }
 

--- a/NSAPITests.h	Thu Mar 03 21:04:29 2016 +0000
+++ b/NSAPITests.h	Thu Apr 21 01:54:51 2016 -0500
@@ -17,8 +17,8 @@
 #ifndef NSAPI_TESTS_H
 #define NSAPI_TESTS_H
 
-#include "NetworkInterface.h"
+#include "NetworkStack.h"
 
-int nsapi_tests(const char *name, NetworkInterface *iface, const char *test_address, uint16_t test_port);
+int nsapi_tests(const char *name, NetworkStack *iface, const char *test_host, uint16_t test_port);
 
 #endif