Cellular: Unit tests for Non-IP socket

Author: Mirela Chirica

UNITTESTS/features/cellular/framework/AT/at_cellulardevice/at_cellulardevicetest.cpp

@@ -51,26 +51,26 @@ TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_get_at_handler)
     FileHandle_stub fh1;
     FileHandle_stub fh2;
     FileHandle_stub fh3;
-    AT_CellularDevice dev(&fh1);
+    AT_CellularDevice dev(&fh1); // AT fh1 ref count 1
 
-    EXPECT_TRUE(dev.open_network(&fh1));
+    EXPECT_TRUE(dev.open_network(&fh1)); // AT fh1 ref count 2
     EXPECT_TRUE(dev.open_sms(&fh2));
     AT_CellularBase_stub::handler_value = AT_CellularBase_stub::handler_at_constructor_value;
     EXPECT_TRUE(dev.open_information(&fh3));
     ATHandler_stub::fh_value = &fh1;
-    EXPECT_TRUE(dev.open_power(&fh1));
+    EXPECT_TRUE(dev.open_power(&fh1)); // AT fh1 ref count 3
 
     ATHandler_stub::fh_value = NULL;
 
-    AT_CellularDevice *dev2 = new AT_CellularDevice(&fh1);
-    EXPECT_TRUE(dev2->open_information(&fh1));
-    ATHandler *at = dev2->get_at_handler();
+    AT_CellularDevice *dev2 = new AT_CellularDevice(&fh1); // AT fh1 ref count 4
+    EXPECT_TRUE(dev2->open_information(&fh1)); // AT fh1 ref count 5
+    ATHandler *at = dev2->get_at_handler(); // AT fh1 ref count 6
+    EXPECT_TRUE(at->get_ref_count() == 6);
+    delete dev2; // AT fh1 2 refs deleted -> ref count 4
     EXPECT_TRUE(at->get_ref_count() == 4);
-    delete dev2;
-    EXPECT_TRUE(at->get_ref_count() == 3);
-    AT_CellularDevice dev3(&fh1);
-    EXPECT_TRUE(dev3.release_at_handler(at) == NSAPI_ERROR_OK);
-    EXPECT_TRUE(ATHandler_stub::ref_count == 2);
+    AT_CellularDevice dev3(&fh1); // AT fh1 ref count 5
+    EXPECT_TRUE(dev3.release_at_handler(at) == NSAPI_ERROR_OK); // AT fh1 ref count 4
+    EXPECT_TRUE(ATHandler_stub::ref_count == 4);
 }
 
 TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_open_network)
@@ -129,42 +129,39 @@ TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_close_network)
 {
     FileHandle_stub fh1;
     AT_CellularDevice dev(&fh1);
-    ATHandler_stub::ref_count = 0;
 
     EXPECT_TRUE(dev.open_network(&fh1));
     AT_CellularBase_stub::handler_value = AT_CellularBase_stub::handler_at_constructor_value;
-    EXPECT_TRUE(ATHandler_stub::ref_count == 1);
+    EXPECT_TRUE(ATHandler_stub::ref_count == 2);
 
     dev.close_network();
-    EXPECT_TRUE(ATHandler_stub::ref_count == kATHandler_destructor_ref_ount);
+    EXPECT_TRUE(ATHANDLER_REF_COUNT_AT_DESTRUCTOR == kATHandler_destructor_ref_ount);
 }
 
 TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_close_sms)
 {
     FileHandle_stub fh1;
     AT_CellularDevice dev(&fh1);
-    ATHandler_stub::ref_count = 0;
 
     EXPECT_TRUE(dev.open_sms(&fh1));
     AT_CellularBase_stub::handler_value = AT_CellularBase_stub::handler_at_constructor_value;
-    EXPECT_TRUE(ATHandler_stub::ref_count == 1);
+    EXPECT_TRUE(ATHandler_stub::ref_count == 2);
 
     dev.close_sms();
-    EXPECT_TRUE(ATHandler_stub::ref_count == kATHandler_destructor_ref_ount);
+    EXPECT_TRUE(ATHANDLER_REF_COUNT_AT_DESTRUCTOR == kATHandler_destructor_ref_ount);
 }
 
 TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_close_power)
 {
     FileHandle_stub fh1;
     AT_CellularDevice dev(&fh1);
-    ATHandler_stub::ref_count = 0;
 
     EXPECT_TRUE(dev.open_power(&fh1));
     AT_CellularBase_stub::handler_value = AT_CellularBase_stub::handler_at_constructor_value;
-    EXPECT_TRUE(ATHandler_stub::ref_count == 1);
+    EXPECT_TRUE(ATHandler_stub::ref_count == 2);
 
     dev.close_power();
-    EXPECT_TRUE(ATHandler_stub::ref_count == kATHandler_destructor_ref_ount);
+    EXPECT_TRUE(ATHANDLER_REF_COUNT_AT_DESTRUCTOR == kATHandler_destructor_ref_ount);
 }
 
 TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_close_information)
@@ -188,7 +185,7 @@ TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_close_information)
     AT_CellularBase_stub::handler_value = AT_CellularBase_stub::handler_at_constructor_value;
 
     dev.close_information();
-    EXPECT_TRUE(ATHandler_stub::ref_count == kATHandler_destructor_ref_ount);
+    EXPECT_TRUE(ATHANDLER_REF_COUNT_AT_DESTRUCTOR == kATHandler_destructor_ref_ount);
 
     ATHandler_stub::fh_value = NULL;
 }
@@ -205,7 +202,7 @@ TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_set_timeout)
     EXPECT_TRUE(ATHandler_stub::default_timeout == true);
 
     EXPECT_TRUE(dev.open_sms(&fh1));
-    EXPECT_TRUE(ATHandler_stub::ref_count == 1);
+    EXPECT_TRUE(ATHandler_stub::ref_count == 2);
 
     dev.set_timeout(5000);
     EXPECT_TRUE(ATHandler_stub::timeout == 5000);
@@ -224,7 +221,7 @@ TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_modem_debug_on)
     EXPECT_TRUE(ATHandler_stub::debug_on == true);
 
     EXPECT_TRUE(dev.open_sms(&fh1));
-    EXPECT_TRUE(ATHandler_stub::ref_count == 1);
+    EXPECT_TRUE(ATHandler_stub::ref_count == 2);
 
     dev.modem_debug_on(true);
     EXPECT_TRUE(ATHandler_stub::debug_on == true);
@@ -305,20 +302,20 @@ TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_create_delete_context)
     AT_CellularDevice *dev = new AT_CellularDevice(&fh1);
 
     ATHandler *at = dev->get_at_handler();
-    EXPECT_TRUE(at->get_ref_count() == 1);
+    EXPECT_TRUE(at->get_ref_count() == 2);
     EXPECT_TRUE(dev->release_at_handler(at) == NSAPI_ERROR_OK);
 
     CellularContext *ctx = dev->create_context(NULL);
     delete dev;
 
     dev = new AT_CellularDevice(&fh1);
     at = dev->get_at_handler();
-    EXPECT_TRUE(at->get_ref_count() == 1);
+    EXPECT_TRUE(at->get_ref_count() == 2);
     ctx = dev->create_context(NULL);
     CellularContext *ctx1 = dev->create_context(&fh1);
-    EXPECT_TRUE(at->get_ref_count() == 3);
-    CellularContext *ctx2 = dev->create_context(&fh1);
     EXPECT_TRUE(at->get_ref_count() == 4);
+    CellularContext *ctx2 = dev->create_context(&fh1);
+    EXPECT_TRUE(at->get_ref_count() == 5);
 
     EXPECT_TRUE(ctx);
     EXPECT_TRUE(ctx1);
@@ -329,20 +326,20 @@ TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_create_delete_context)
     EXPECT_TRUE(xx);
 
     dev->delete_context(ctx);
-    EXPECT_TRUE(at->get_ref_count() == 3);
+    EXPECT_TRUE(at->get_ref_count() == 4);
     dev->delete_context(ctx1);
-    EXPECT_TRUE(at->get_ref_count() == 2);
+    EXPECT_TRUE(at->get_ref_count() == 3);
     dev->delete_context(NULL);
-    EXPECT_TRUE(at->get_ref_count() == 2);
+    EXPECT_TRUE(at->get_ref_count() == 3);
     dev->delete_context(ctx2);
-    EXPECT_TRUE(at->get_ref_count() == 1);
+    EXPECT_TRUE(at->get_ref_count() == 2);
 
     ctx = dev->create_context(NULL);
-    EXPECT_TRUE(at->get_ref_count() == 2);
-    ctx1 = dev->create_context(&fh1);
     EXPECT_TRUE(at->get_ref_count() == 3);
-    ctx2 = dev->create_context(&fh1);
+    ctx1 = dev->create_context(&fh1);
     EXPECT_TRUE(at->get_ref_count() == 4);
+    ctx2 = dev->create_context(&fh1);
+    EXPECT_TRUE(at->get_ref_count() == 5);
     EXPECT_TRUE(dev->release_at_handler(at) == NSAPI_ERROR_OK);
     EXPECT_TRUE(ctx);
     EXPECT_TRUE(ctx1);

UNITTESTS/features/netsocket/cellular/CellularNonIPSocket/test_CellularNonIPSocket.cpp

@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2018, Arm Limited and affiliates
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "gtest/gtest.h"
+#include "features/netsocket/cellular/CellularNonIPSocket.h"
+#include "CellularContext_stub.h"
+
+using namespace mbed;
+
+// Control the rtos EventFlags stub. See EventFlags_stub.cpp
+extern std::list<uint32_t> eventFlagsStubNextRetval;
+
+static bool callback_is_called;
+static void my_callback()
+{
+    callback_is_called = true;
+}
+
+class TestCellularNonIPSocket : public testing::Test {
+protected:
+    CellularNonIPSocket *socket;
+    ControlPlane_netif_stub *cp_netif;
+    CellularContext_stub cellular_context;
+    nsapi_size_t dataSize;
+    char dataBuf[10];
+
+    virtual void SetUp()
+    {
+        socket = new CellularNonIPSocket();
+        cp_netif = NULL;
+        dataSize = 10;
+    }
+
+    virtual void TearDown()
+    {
+        delete socket;
+    }
+};
+
+TEST_F(TestCellularNonIPSocket, open_null_cp_netif)
+{
+    EXPECT_EQ(socket->open(static_cast<ControlPlane_netif *>(NULL)), NSAPI_ERROR_PARAMETER);
+}
+
+TEST_F(TestCellularNonIPSocket, open_null_context)
+{
+    EXPECT_EQ(socket->open(static_cast<CellularContext *>(NULL)), NSAPI_ERROR_PARAMETER);
+}
+
+TEST_F(TestCellularNonIPSocket, open_context)
+{
+    EXPECT_EQ(socket->open((CellularContext *)&cellular_context), NSAPI_ERROR_OK);
+}
+
+TEST_F(TestCellularNonIPSocket, open_cp_netif)
+{
+    cp_netif = cellular_context.get_cp_netif();
+    EXPECT_EQ(socket->open((ControlPlane_netif *)cp_netif), NSAPI_ERROR_OK);
+}
+
+TEST_F(TestCellularNonIPSocket, open_twice)
+{
+    EXPECT_EQ(socket->open((CellularContext *)&cellular_context), NSAPI_ERROR_OK);
+    EXPECT_EQ(socket->open((CellularContext *)&cellular_context), NSAPI_ERROR_PARAMETER);
+}
+
+TEST_F(TestCellularNonIPSocket, close)
+{
+    socket->open((CellularContext *)&cellular_context);
+    EXPECT_EQ(socket->close(), NSAPI_ERROR_OK);
+}
+
+TEST_F(TestCellularNonIPSocket, close_no_open)
+{
+    EXPECT_EQ(socket->close(), NSAPI_ERROR_NO_SOCKET);
+}
+
+TEST_F(TestCellularNonIPSocket, sigio)
+{
+    callback_is_called = false;
+    socket->open((CellularContext *)&cellular_context);
+    socket->sigio(mbed::callback(my_callback));
+    socket->close(); // Trigger event;
+    EXPECT_EQ(callback_is_called, true);
+}
+
+/* send */
+
+TEST_F(TestCellularNonIPSocket, send_no_open)
+{
+    EXPECT_EQ(socket->send((char *)dataBuf, dataSize), NSAPI_ERROR_NO_SOCKET);
+}
+
+TEST_F(TestCellularNonIPSocket, send_error_would_block)
+{
+    socket->open((CellularContext *)&cellular_context);
+    cp_netif = cellular_context.get_cp_netif();
+    cp_netif->return_value = NSAPI_ERROR_WOULD_BLOCK;
+    eventFlagsStubNextRetval.push_back(osFlagsError); // Break the wait loop
+    EXPECT_EQ(socket->send(dataBuf, dataSize), NSAPI_ERROR_WOULD_BLOCK);
+}
+
+TEST_F(TestCellularNonIPSocket, send_error_other)
+{
+    socket->open((CellularContext *)&cellular_context);
+    cp_netif = cellular_context.get_cp_netif();
+    cp_netif->return_value = NSAPI_ERROR_NO_MEMORY;
+    EXPECT_EQ(socket->send(dataBuf, dataSize), NSAPI_ERROR_NO_MEMORY);
+}
+
+TEST_F(TestCellularNonIPSocket, send_error_no_timeout)
+{
+    socket->open((CellularContext *)&cellular_context);
+    cp_netif = cellular_context.get_cp_netif();
+    cp_netif->return_value = NSAPI_ERROR_WOULD_BLOCK;
+    socket->set_blocking(false);
+    EXPECT_EQ(socket->send(dataBuf, dataSize), NSAPI_ERROR_WOULD_BLOCK);
+}
+
+TEST_F(TestCellularNonIPSocket, send)
+{
+    socket->open((CellularContext *)&cellular_context);
+    cp_netif = cellular_context.get_cp_netif();
+    cp_netif->return_value = dataSize;
+    EXPECT_EQ(socket->send(dataBuf, dataSize), dataSize);
+}
+
+TEST_F(TestCellularNonIPSocket, recv)
+{
+    EXPECT_EQ(socket->recv(&dataBuf, dataSize), NSAPI_ERROR_NO_SOCKET);
+
+    socket->open((CellularContext *)&cellular_context);
+    cp_netif = cellular_context.get_cp_netif();
+
+    cp_netif->return_value = 100;
+    EXPECT_EQ(socket->recv(&dataBuf, dataSize), 100);
+
+    cp_netif->return_value = NSAPI_ERROR_WOULD_BLOCK;
+    eventFlagsStubNextRetval.push_back(0);
+    eventFlagsStubNextRetval.push_back(osFlagsError); // Break the wait loop
+    EXPECT_EQ(socket->recv(&dataBuf, dataSize), NSAPI_ERROR_WOULD_BLOCK);
+}

UNITTESTS/features/netsocket/cellular/CellularNonIPSocket/unittest.cmake

@@ -0,0 +1,21 @@
+
+####################
+# UNIT TESTS
+####################
+
+# Add test specific include paths
+set(unittest-includes ${unittest-includes}
+  ../features/netsocket/cellular
+)
+
+set(unittest-sources
+  ../features/netsocket/cellular/CellularNonIPSocket.cpp
+)
+
+set(unittest-test-sources
+  features/netsocket/cellular/CellularNonIPSocket/test_CellularNonIPSocket.cpp
+  stubs/NetworkInterface_stub.cpp
+  stubs/NetworkStack_stub.cpp
+  stubs/EventFlags_stub.cpp
+  stubs/Mutex_stub.cpp
+)

UNITTESTS/stubs/ATHandler_stub.h

@@ -26,11 +26,13 @@
 #ifndef __AT_HANDLER_STUB_H__
 #define __AT_HANDLER_STUB_H__
 
+#define ATHANDLER_REF_COUNT_AT_DESTRUCTOR -909
+
 static const int kRead_string_table_size = 100;
 static const int kRead_int_table_size = 100;
 static const int kResp_stop_count_default = 100;
 // set reference count to -909 to separate it from zero so we can test that ATHandler is really deleted.
-static const int kATHandler_destructor_ref_ount = -909;
+static const int kATHandler_destructor_ref_ount = ATHANDLER_REF_COUNT_AT_DESTRUCTOR;
 static const int kATHandler_urc_table_max_size = 10;
 static const int kATHandler_urc_string_max_size = 16;
 

UNITTESTS/stubs/AT_CellularContext_stub.cpp

@@ -21,7 +21,7 @@ using namespace mbed;
 
 AT_CellularContext::AT_CellularContext(ATHandler &at, CellularDevice *device, const char *apn,  bool cp_req, bool nonip_req) :
     AT_CellularBase(at), _is_blocking(true), _is_connected(false),
-    _current_op(OP_INVALID), _device(device), _nw(0), _fh(0), _cp_req(cp_req), _nonip_req(nonip_req), _cp_in_use(false), _cp_netif(NULL)
+    _current_op(OP_INVALID), _device(device), _nw(0), _fh(0), _cp_req(cp_req), _nonip_req(nonip_req), _cp_in_use(false)
 {
     _stack = NULL;
     _pdp_type = DEFAULT_PDP_TYPE;
@@ -36,6 +36,7 @@ AT_CellularContext::AT_CellularContext(ATHandler &at, CellularDevice *device, co
     _cid = -1;
     _new_context_set = false;
     _next = NULL;
+    _cp_netif = NULL;
 }
 
 AT_CellularContext::~AT_CellularContext()