[unittests] Improve coverage

For the following classes:
* DTLSSocket
* NetworkInterface
* TLSSocketWrapper

Author: michalpasztamobica

UNITTESTS/features/netsocket/DTLSSocket/test_DTLSSocket.cpp

@@ -54,6 +54,12 @@ TEST_F(TestDTLSSocket, constructor)
     EXPECT_TRUE(socket);
 }
 
+TEST_F(TestDTLSSocket, connect_no_socket)
+{
+    EXPECT_TRUE(socket);
+    EXPECT_EQ(socket->connect("127.0.0.1", 1024), NSAPI_ERROR_NO_SOCKET);
+}
+
 /* connect */
 
 TEST_F(TestDTLSSocket, connect)

UNITTESTS/features/netsocket/NetworkInterface/test_NetworkInterface.cpp

@@ -64,6 +64,7 @@ class TestNetworkInterface : public testing::Test {
 TEST_F(TestNetworkInterface, constructor)
 {
     EXPECT_TRUE(iface);
+    iface->set_as_default(); //Empty function. Just trigger it, so it doesn't obscure coverage reports.
 }
 
 // get_default_instance is tested along with the implementations of NetworkInterface.
@@ -92,6 +93,12 @@ TEST_F(TestNetworkInterface, get_gateway)
     EXPECT_EQ(iface->get_gateway(), n);
 }
 
+TEST_F(TestNetworkInterface, get_interface_name)
+{
+    char *n = 0;
+    EXPECT_EQ(iface->get_interface_name(n), 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);
@@ -168,7 +175,7 @@ TEST_F(TestNetworkInterface, add_event_listener)
 
 TEST_F(TestNetworkInterface, remove_event_listener)
 {
-    // Add two callback and check that both are called
+    // Add two callbacks and check that both are called
     callback_is_called = false;
     second_callback_called = false;
     iface->add_event_listener(my_iface_callback);
@@ -215,7 +222,6 @@ TEST_F(TestNetworkInterface, correct_event_listener_per_interface)
     EXPECT_EQ(second_callback_called, true);
 
     iface->remove_event_listener(my_iface_callback);
-    iface2->remove_event_listener(my_iface_callback2);
-
+    // Do not call iface2->remove_event_listener, so the destructor can take care of this.
     delete iface2;
 }

UNITTESTS/features/netsocket/TLSSocketWrapper/test_TLSSocketWrapper.cpp

@@ -105,6 +105,20 @@ TEST_F(TestTLSSocketWrapper, constructor_hostname)
     delete wrapper2;
 }
 
+TEST_F(TestTLSSocketWrapper, no_socket)
+{
+    TLSSocketWrapper *wrapperTmp = new TLSSocketWrapper(NULL);
+    const SocketAddress a("127.0.0.1", 1024);
+    EXPECT_EQ(wrapperTmp->connect(a), NSAPI_ERROR_NO_SOCKET);
+    EXPECT_EQ(wrapperTmp->bind(a), NSAPI_ERROR_NO_SOCKET);
+    EXPECT_EQ(wrapperTmp->setsockopt(0, 0, 0, 0), NSAPI_ERROR_NO_SOCKET);
+    EXPECT_EQ(wrapperTmp->getsockopt(0, 0, 0, 0), NSAPI_ERROR_NO_SOCKET);
+    EXPECT_EQ(wrapperTmp->send(dataBuf, dataSize), NSAPI_ERROR_NO_SOCKET);
+    EXPECT_EQ(wrapperTmp->recv(dataBuf, dataSize), NSAPI_ERROR_NO_SOCKET);
+    EXPECT_EQ(wrapperTmp->close(), NSAPI_ERROR_NO_SOCKET);
+    delete wrapperTmp;
+}
+
 /* connect */
 
 TEST_F(TestTLSSocketWrapper, connect)
@@ -194,6 +208,11 @@ TEST_F(TestTLSSocketWrapper, connect_handshake_fail_ssl_handshake_in_progress)
     mbedtls_stub.retArray[2] = MBEDTLS_ERR_SSL_WANT_READ; // mbedtls_ssl_handshake error
     const SocketAddress a("127.0.0.1", 1024);
     EXPECT_EQ(wrapper->connect(a), NSAPI_ERROR_IN_PROGRESS);
+
+    // Check that send will fail in this situation.
+    mbedtls_stub.retArray[3] = MBEDTLS_ERR_SSL_WANT_READ; // mbedtls_ssl_handshake error
+    eventFlagsStubNextRetval.push_back(osFlagsError); // Break the wait loop
+    EXPECT_EQ(wrapper->send(dataBuf, dataSize), NSAPI_ERROR_WOULD_BLOCK);
 }
 
 TEST_F(TestTLSSocketWrapper, connect_handshake_fail_ssl_get_verify_result)
@@ -243,6 +262,17 @@ TEST_F(TestTLSSocketWrapper, send_error_would_block)
     EXPECT_EQ(wrapper->send(dataBuf, dataSize), NSAPI_ERROR_WOULD_BLOCK);
 }
 
+TEST_F(TestTLSSocketWrapper, send_device_error)
+{
+    transport->open((NetworkStack *)&stack);
+    mbedtls_stub.useCounter = true;
+    mbedtls_stub.retArray[3] = MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE; // mbedtls_ssl_write
+    eventFlagsStubNextRetval.push_back(osFlagsError); // Break the wait loop
+    const SocketAddress a("127.0.0.1", 1024);
+    EXPECT_EQ(wrapper->connect(a), NSAPI_ERROR_OK);
+    EXPECT_EQ(wrapper->send(dataBuf, dataSize), NSAPI_ERROR_DEVICE_ERROR);
+}
+
 TEST_F(TestTLSSocketWrapper, send_to)
 {
     transport->open((NetworkStack *)&stack);
@@ -294,6 +324,17 @@ TEST_F(TestTLSSocketWrapper, recv_would_block)
     EXPECT_EQ(wrapper->recv(dataBuf, dataSize), NSAPI_ERROR_WOULD_BLOCK);
 }
 
+TEST_F(TestTLSSocketWrapper, recv_device_error)
+{
+    transport->open((NetworkStack *)&stack);
+    mbedtls_stub.useCounter = true;
+    mbedtls_stub.retArray[3] = MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE; // mbedtls_ssl_write
+    const SocketAddress a("127.0.0.1", 1024);
+    EXPECT_EQ(wrapper->connect(a), NSAPI_ERROR_OK);
+    eventFlagsStubNextRetval.push_back(osFlagsError); // Break the wait loop
+    EXPECT_EQ(wrapper->recv(dataBuf, dataSize), NSAPI_ERROR_DEVICE_ERROR);
+}
+
 TEST_F(TestTLSSocketWrapper, recv_from_no_socket)
 {
     SocketAddress a("127.0.0.1", 1024);