Merge pull request #8138 from michalpasztamobica/master

Unit tests for TCPSocket, TCPServer, UDPSocket, NetworkStack, InternetSocket

Author: 0xc0170

UNITTESTS/features/netsocket/InternetSocket/test_InternetSocket.cpp

@@ -19,17 +19,13 @@
 #include "features/netsocket/InternetSocket.h"
 #include "NetworkStack_stub.h"
 
+extern std::list<uint32_t> eventFlagsStubNextRetval;
+
+// InternetSocket is an abstract class, so we have to test it via its child.
 class stubInternetSocket : public InternetSocket {
 protected:
     nsapi_error_t return_value = 0;
 public:
-    virtual void event()
-    {
-        if (_callback) {
-            _callback.call();
-        }
-    }
-
     virtual nsapi_error_t connect(const SocketAddress &address)
     {
         return return_value;
@@ -60,6 +56,15 @@ class stubInternetSocket : public InternetSocket {
     {
         return return_value;
     }
+
+    // Testing functions
+    void add_reader (void) { _readers++;}
+    void rem_reader (void) { _readers--;}
+    void add_writer (void) { _writers++;}
+    void rem_writer (void) { _writers--;}
+    void add_pending (void) { _pending++;}
+    void rem_pending (void) { _pending--;}
+
 protected:
     virtual nsapi_protocol_t get_proto()
     {
@@ -94,7 +99,6 @@ TEST_F(TestInternetSocket, constructor)
     EXPECT_TRUE(socket);
 }
 
-
 TEST_F(TestInternetSocket, open_null_stack)
 {
     EXPECT_EQ(socket->open(NULL), NSAPI_ERROR_PARAMETER);
@@ -126,34 +130,81 @@ TEST_F(TestInternetSocket, close)
     EXPECT_EQ(socket->close(), NSAPI_ERROR_OK);
 }
 
+TEST_F(TestInternetSocket, close_no_open)
+{
+    stack.return_value = NSAPI_ERROR_OK;
+    EXPECT_EQ(socket->close(), NSAPI_ERROR_OK);
+}
+
+TEST_F(TestInternetSocket, close_during_read)
+{
+    stack.return_value = NSAPI_ERROR_OK;
+    socket->open((NetworkStack *)&stack);
+    // when c++11 is available use something like the code below to test the blocking behavior
+    // socket->add_reader();
+    // std::async(c[](){std::this_thread::sleep_for(1ms); socket->rem_reader()});
+    EXPECT_EQ(socket->close(), NSAPI_ERROR_OK);
+}
+
 TEST_F(TestInternetSocket, modify_multicast_group)
 {
     SocketAddress a("127.0.0.1", 1024);
     stack.return_value = NSAPI_ERROR_OK;
     socket->open((NetworkStack *)&stack);
-
+    // when c++11 is available use something like the code below to test the blocking behavior
+    // socket->add_reader();
+    // std::async(c[](){std::this_thread::sleep_for(1ms); socket->rem_reader()});
     EXPECT_EQ(socket->join_multicast_group(a), NSAPI_ERROR_UNSUPPORTED);
     EXPECT_EQ(socket->leave_multicast_group(a), NSAPI_ERROR_UNSUPPORTED);
 }
 
-TEST_F(TestInternetSocket, set_blocking)
+// set_blocking and set_timeout are tested within TCPSocket.
+
+TEST_F(TestInternetSocket, bind_no_socket)
+{
+    EXPECT_EQ(socket->bind(1), NSAPI_ERROR_NO_SOCKET);
+}
+
+TEST_F(TestInternetSocket, bind)
+{
+    socket->open((NetworkStack *)&stack);
+    EXPECT_EQ(socket->bind("127.0.0.1", 80), NSAPI_ERROR_OK);
+}
+
+TEST_F(TestInternetSocket, bind_nullstring)
 {
-    socket->set_blocking(false);
-    socket->set_blocking(true);
+    socket->open((NetworkStack *)&stack);
+    EXPECT_EQ(socket->bind(NULL, 80), NSAPI_ERROR_OK);
 }
 
+// setsockopt and getsockopt are really just calling the underlying stack functions
+
 TEST_F(TestInternetSocket, setsockopt_no_stack)
 {
-    socket->close();
     EXPECT_EQ(socket->setsockopt(0, 0, 0, 0), NSAPI_ERROR_NO_SOCKET);
 }
 
+TEST_F(TestInternetSocket, setsockopt)
+{
+    socket->open((NetworkStack *)&stack);
+    EXPECT_EQ(socket->setsockopt(0, 0, 0, 0), NSAPI_ERROR_UNSUPPORTED);
+}
+
+TEST_F(TestInternetSocket, getsockopt_no_stack)
+{
+    EXPECT_EQ(socket->getsockopt(0, 0, 0, 0), NSAPI_ERROR_NO_SOCKET);
+}
+
+TEST_F(TestInternetSocket, getsockopt)
+{
+    socket->open((NetworkStack *)&stack);
+    EXPECT_EQ(socket->getsockopt(0, 0, 0, 0), NSAPI_ERROR_UNSUPPORTED);
+}
+
 TEST_F(TestInternetSocket, sigio)
 {
     callback_is_called = false;
-    // I'm calling sigio() through the DEPRECATED method, just to get coverage for both.
-    // Not sure if this is wise at all, we should not aim for 100%
     socket->sigio(mbed::callback(my_callback));
-    socket->event();
+    socket->close(); // Trigger event;
     EXPECT_EQ(callback_is_called, true);
 }

UNITTESTS/features/netsocket/NetworkInterface/test_NetworkInterface.cpp

@@ -17,6 +17,7 @@
 
 #include "gtest/gtest.h"
 #include "features/netsocket/NetworkInterface.h"
+#include "NetworkStack_stub.h"
 
 class stubNetworkInterface : public NetworkInterface {
     virtual nsapi_error_t connect()
@@ -29,8 +30,10 @@ class stubNetworkInterface : public NetworkInterface {
     };
     virtual NetworkStack *get_stack()
     {
-        return NULL;
+        return &stack;
     };
+public:
+    NetworkStackstub stack;
 };
 
 class TestNetworkInterface : public testing::Test {
@@ -53,8 +56,79 @@ TEST_F(TestNetworkInterface, constructor)
     EXPECT_TRUE(iface);
 }
 
+// get_default_instance is tested along with the implementations of NetworkInterface.
+
 TEST_F(TestNetworkInterface, get_mac_address)
 {
     char *n = 0;
     EXPECT_EQ(iface->get_mac_address(), n);
 }
+
+TEST_F(TestNetworkInterface, get_ip_address)
+{
+    char *n = 0;
+    EXPECT_EQ(iface->get_ip_address(), n);
+}
+
+TEST_F(TestNetworkInterface, get_netmask)
+{
+    char *n = 0;
+    EXPECT_EQ(iface->get_netmask(), n);
+}
+
+TEST_F(TestNetworkInterface, get_gateway)
+{
+    char *n = 0;
+    EXPECT_EQ(iface->get_gateway(), n);
+}
+
+TEST_F(TestNetworkInterface, set_network)
+{
+    EXPECT_EQ(iface->set_network("127.0.0.1", "255.255.0.0", "127.0.0.1"), NSAPI_ERROR_UNSUPPORTED);
+}
+
+TEST_F(TestNetworkInterface, set_dhcp)
+{
+    EXPECT_EQ(iface->set_dhcp(true), NSAPI_ERROR_OK);
+    EXPECT_EQ(iface->set_dhcp(false), NSAPI_ERROR_UNSUPPORTED);
+}
+
+TEST_F(TestNetworkInterface, gethostbyname)
+{
+    SocketAddress a;
+    EXPECT_EQ(iface->gethostbyname("host", &a, NSAPI_UNSPEC), NSAPI_ERROR_OK);
+}
+
+
+static bool callback_is_called;
+static void my_callback(nsapi_error_t result, SocketAddress *address)
+{
+    (void)result;
+    (void)address;
+    callback_is_called = true;
+}
+
+TEST_F(TestNetworkInterface, gethostbyname_async)
+{
+    SocketAddress a;
+    EXPECT_EQ(iface->gethostbyname_async("host", mbed::callback(my_callback), NSAPI_UNSPEC), NSAPI_ERROR_OK);
+    EXPECT_EQ(iface->gethostbyname_async_cancel(1), NSAPI_ERROR_OK);
+}
+
+TEST_F(TestNetworkInterface, add_dns_server)
+{
+    SocketAddress a("127.0.0.1", 1024);
+    EXPECT_EQ(iface->add_dns_server(a), NSAPI_ERROR_OK);
+}
+
+TEST_F(TestNetworkInterface, get_connection_status)
+{
+    EXPECT_EQ(iface->get_connection_status(), NSAPI_ERROR_UNSUPPORTED);
+}
+
+TEST_F(TestNetworkInterface, set_blocking)
+{
+    EXPECT_EQ(iface->set_blocking(true), NSAPI_ERROR_UNSUPPORTED);
+}
+
+// No way to test attach as it doesn't do or return anything.

UNITTESTS/features/netsocket/NetworkInterface/unittest.cmake

@@ -5,10 +5,21 @@
 
 # Source files
 set(unittest-sources
+  ../features/netsocket/SocketAddress.cpp
+  ../features/netsocket/NetworkStack.cpp
   ../features/netsocket/NetworkInterface.cpp
+  ../features/frameworks/nanostack-libservice/source/libip4string/ip4tos.c
+  ../features/frameworks/nanostack-libservice/source/libip4string/stoip4.c
 )
 
 # Test files
 set(unittest-test-sources
+  stubs/Mutex_stub.cpp
+  stubs/mbed_assert_stub.c
+  stubs/equeue_stub.c
+  stubs/EventQueue_stub.cpp
+  stubs/mbed_shared_queues_stub.cpp
+  stubs/nsapi_dns_stub.cpp
+  stubs/EventFlags_stub.cpp
   features/netsocket/NetworkInterface/test_NetworkInterface.cpp
 )