Merge pull request #7269 from jarvte/add_cellular_network_tests

Cellular: add cellular network tests

features/cellular/TESTS/api/cellular_network/main.cpp

@@ -0,0 +1,418 @@
+/*
+ * 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.
+ */
+
+
+#if !defined(MBED_CONF_NSAPI_PRESENT)
+#error [NOT_SUPPORTED] A json configuration file is needed. Skipping this build.
+#endif
+
+#include "CellularUtil.h" // for CELLULAR_ helper macros
+#include "CellularTargets.h"
+
+#ifndef CELLULAR_DEVICE
+#error [NOT_SUPPORTED] CELLULAR_DEVICE must be defined
+#endif
+
+#ifndef MBED_CONF_APP_CELLULAR_SIM_PIN
+#error [NOT_SUPPORTED] SIM pin code is needed. Skipping this build.
+#endif
+
+#include "greentea-client/test_env.h"
+#include "unity.h"
+#include "utest.h"
+
+#include "mbed.h"
+
+#include "AT_CellularNetwork.h"
+#include "CellularConnectionFSM.h"
+#include "CellularDevice.h"
+#include "../../cellular_tests_common.h"
+#include CELLULAR_STRINGIFY(CELLULAR_DEVICE.h)
+
+#define NETWORK_TIMEOUT (180*1000)
+
+static UARTSerial cellular_serial(MDMTXD, MDMRXD, MBED_CONF_PLATFORM_DEFAULT_SERIAL_BAUD_RATE);
+static EventQueue queue(8 * EVENTS_EVENT_SIZE);
+static rtos::Semaphore network_semaphore(0);
+static CellularConnectionFSM cellular;
+static CellularConnectionFSM::CellularState cellular_target_state;
+static CELLULAR_DEVICE *device;
+static CellularNetwork* nw;
+
+
+static bool fsm_callback(int state, int next_state)
+{
+    if (next_state == cellular_target_state) {
+        TEST_ASSERT(network_semaphore.release() == osOK);
+        return false;
+    }
+    return true;
+}
+
+// test methods that are already run in state machine (CellularConnectionFSM) but as it might change
+// we wan't to run these 'manually' also
+static void test_network_interface_fsm()
+{
+#if defined (MDMRTS) && defined (MDMCTS)
+    cellular_serial.set_flow_control(SerialBase::RTSCTS, MDMRTS, MDMCTS);
+#endif
+    device = new CELLULAR_DEVICE(queue);
+    TEST_ASSERT(device != NULL);
+
+    CellularNetwork* nw = device->open_network(&cellular_serial);
+    TEST_ASSERT(nw != NULL);
+    TEST_ASSERT(nw->init() == NSAPI_ERROR_OK);
+
+    delete device;
+    device = NULL;
+}
+
+static void init_network_interface()
+{
+    cellular.set_serial(&cellular_serial);
+    TEST_ASSERT(cellular.init() == NSAPI_ERROR_OK);
+    cellular.set_callback(&fsm_callback);
+    TEST_ASSERT(cellular.start_dispatch() == NSAPI_ERROR_OK);
+    cellular.set_sim_pin(MBED_CONF_APP_CELLULAR_SIM_PIN);
+#ifdef MBED_CONF_APP_APN
+    CellularNetwork *network = cellular.get_network();
+    TEST_ASSERT(network->set_credentials(MBED_CONF_APP_APN) == NSAPI_ERROR_OK);
+#endif
+    cellular_target_state = CellularConnectionFSM::STATE_REGISTERING_NETWORK;
+    TEST_ASSERT(cellular.continue_to_state(cellular_target_state) == NSAPI_ERROR_OK);
+    TEST_ASSERT(network_semaphore.wait(NETWORK_TIMEOUT) == 1);
+}
+
+
+static bool get_network_registration(CellularNetwork::RegistrationType type,
+        CellularNetwork::RegistrationStatus &status, bool &is_registered)
+{
+    is_registered = false;
+    nsapi_error_t err = nw->get_registration_status(type, status);
+    TEST_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_UNSUPPORTED);
+
+    switch (status) {
+        case CellularNetwork::RegisteredRoaming:
+        case CellularNetwork::RegisteredHomeNetwork:
+            is_registered = true;
+            break;
+        case CellularNetwork::RegisteredSMSOnlyRoaming:
+        case CellularNetwork::RegisteredSMSOnlyHome:
+        case CellularNetwork::RegisteredCSFBNotPreferredRoaming:
+        case CellularNetwork::RegisteredCSFBNotPreferredHome:
+        case CellularNetwork::AttachedEmergencyOnly:
+        case CellularNetwork::RegistrationDenied:
+        case CellularNetwork::NotRegistered:
+        case CellularNetwork::Unknown:
+        case CellularNetwork::SearchingNetwork:
+        default:
+            break;
+    }
+    return true;
+}
+
+static bool is_registered()
+{
+    CellularNetwork::RegistrationStatus status;
+    bool is_registered = false;
+
+    for (int type = 0; type < CellularNetwork::C_MAX; type++) {
+        if (get_network_registration((CellularNetwork::RegistrationType) type, status, is_registered)) {
+            if (is_registered) {
+                break;
+            }
+        }
+    }
+
+    return is_registered;
+}
+
+static void nw_callback(nsapi_event_t ev, intptr_t intptr)
+{
+}
+
+static void test_network_registration()
+{
+    cellular.get_device()->set_timeout(10*1000);
+    nw = cellular.get_network();
+    TEST_ASSERT(nw != NULL);
+
+    nw->attach(&nw_callback);
+
+    bool success = false;
+    for (int type = 0; type < CellularNetwork::C_MAX; type++) {
+        if (!nw->set_registration_urc((CellularNetwork::RegistrationType)type, true)) {
+            success = true;
+        }
+    }
+    // each modem should support at least one registration type
+    TEST_ASSERT(success);
+
+    int sanity_count = 0;
+    while (is_registered() == false) {
+        if (sanity_count == 0) {
+            TEST_ASSERT(nw->set_registration() == NSAPI_ERROR_OK);
+        }
+        sanity_count++;
+        wait(2);
+        TEST_ASSERT(sanity_count < 60);
+    }
+
+    // device was registered right away, test set_registration call
+    if (sanity_count == 0) {
+        TEST_ASSERT(nw->set_registration() == NSAPI_ERROR_OK);
+    }
+
+    CellularNetwork::NWRegisteringMode reg_mode = CellularNetwork::NWModeDeRegister;
+    TEST_ASSERT(nw->get_network_registering_mode(reg_mode) == NSAPI_ERROR_OK);
+    TEST_ASSERT(reg_mode == CellularNetwork::NWModeAutomatic);
+}
+
+static void test_attach()
+{
+    TEST_ASSERT(nw->set_attach() == NSAPI_ERROR_OK);
+
+    CellularNetwork::AttachStatus status;
+    TEST_ASSERT(nw->get_attach(status) == NSAPI_ERROR_OK);
+    TEST_ASSERT(status == CellularNetwork::Attached);
+}
+
+static void test_activate_context()
+{
+    TEST_ASSERT(nw->activate_context() == NSAPI_ERROR_OK);
+}
+
+static void test_connect()
+{
+    TEST_ASSERT(nw->connect() == NSAPI_ERROR_OK);
+    nsapi_connection_status_t st =  nw->get_connection_status();
+    TEST_ASSERT(st == NSAPI_STATUS_GLOBAL_UP);
+}
+
+static void test_credentials()
+{
+    TEST_ASSERT(nw->set_credentials(NULL, "username", "pass") == NSAPI_ERROR_OK);
+    TEST_ASSERT(nw->set_credentials("internet", NULL, "pass") == NSAPI_ERROR_OK);
+    TEST_ASSERT(nw->set_credentials("internet", "user", NULL) == NSAPI_ERROR_OK);
+    TEST_ASSERT(nw->set_credentials("internet", CellularNetwork::NOAUTH, "user", "pass") == NSAPI_ERROR_OK);
+}
+
+static void test_other()
+{
+    TEST_ASSERT(nw->get_3gpp_error() == 0);
+
+    CellularNetwork::RateControlExceptionReports reports;
+    CellularNetwork::RateControlUplinkTimeUnit timeUnit;
+    int uplinkRate;
+    // can't test values as they are optional
+    nsapi_error_t err = nw->get_rate_control(reports, timeUnit, uplinkRate);
+    tr_error("get_rate_control: %d", err);
+    TEST_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_DEVICE_ERROR);
+#if CELLULAR_DEVICE != QUECTEL_BG96 // QUECTEL_BG96 does not give any specific reason for device error
+    if (err == NSAPI_ERROR_DEVICE_ERROR) {
+        TEST_ASSERT(((AT_CellularNetwork*)nw)->get_device_error().errCode == 100 && // 100 == unknown command for modem
+                ((AT_CellularNetwork*)nw)->get_device_error().errType == 3); // 3 == CME error from the modem
+    }
+#endif
+
+    uplinkRate = -1;
+    err = nw->get_apn_backoff_timer(uplinkRate);
+    TEST_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_DEVICE_ERROR);
+    if (err == NSAPI_ERROR_DEVICE_ERROR) {
+#if CELLULAR_DEVICE != QUECTEL_BG96 // QUECTEL_BG96 does not give any specific reason for device error
+            TEST_ASSERT(((AT_CellularNetwork*)nw)->get_device_error().errCode == 100 && // 100 == unknown command for modem
+                    ((AT_CellularNetwork*)nw)->get_device_error().errType == 3); // 3 == CME error from the modem
+#endif
+    } else {
+        TEST_ASSERT(uplinkRate >= 0);
+    }
+
+    err = nw->set_access_technology(CellularNetwork::RAT_GSM);
+    TEST_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_UNSUPPORTED);
+
+    // scanning of operators might take a long time
+    cellular.get_device()->set_timeout(240*1000);
+    CellularNetwork::operList_t operators;
+    TEST_ASSERT(nw->scan_plmn(operators, uplinkRate) == NSAPI_ERROR_OK);
+    cellular.get_device()->set_timeout(10*1000);
+
+
+    // all current targets support IPV4
+    nsapi_ip_stack_t stack_type = IPV4_STACK;
+    TEST_ASSERT(nw->set_stack_type(stack_type) == NSAPI_ERROR_OK);
+    TEST_ASSERT(nw->get_stack_type() == stack_type);
+
+    CellularNetwork::pdpContextList_t params_list;
+    err = nw->get_pdpcontext_params(params_list);
+
+    TEST_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_DEVICE_ERROR);
+    if (err == NSAPI_ERROR_DEVICE_ERROR) {
+#if CELLULAR_DEVICE != TELIT_HE910 // TELIT_HE910 just gives an error and no specific error number so we can't know is this real error or that modem/network does not support the command
+        TEST_ASSERT(((AT_CellularNetwork*)nw)->get_device_error().errCode == 100 && // 100 == unknown command for modem
+                ((AT_CellularNetwork*)nw)->get_device_error().errType == 3); // 3 == CME error from the modem
+#endif
+    } else {
+        // should have some values, only not optional are apn and bearer id
+        CellularNetwork::pdpcontext_params_t* params = params_list.get_head();
+        TEST_ASSERT(strlen(params->apn) > 0);
+        TEST_ASSERT(params->bearer_id >= 0)
+    }
+
+    int rxlev = -1, ber = -1, rscp = -1, ecno = -1, rsrq = -1, rsrp = -1;
+    err = nw->get_extended_signal_quality(rxlev, ber, rscp, ecno, rsrq, rsrp);
+    TEST_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_DEVICE_ERROR);
+    if (err == NSAPI_ERROR_DEVICE_ERROR) {
+#if CELLULAR_DEVICE != QUECTEL_BG96 // QUECTEL_BG96 does not give any specific reason for device error
+        TEST_ASSERT(((AT_CellularNetwork*)nw)->get_device_error().errCode == 100 && // 100 == unknown command for modem
+                ((AT_CellularNetwork*)nw)->get_device_error().errType == 3); // 3 == CME error from the modem
+#endif
+    } else {
+        // we should have some values which are not optional
+        TEST_ASSERT(rxlev >= 0 && ber >= 0 && rscp >= 0 && ecno >= 0 && rsrq >= 0 && rsrp >= 0);
+    }
+
+    int rssi = -1;
+    ber = -1;
+    err = nw->get_signal_quality(rssi, ber);
+    TEST_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_DEVICE_ERROR);
+    if (err == NSAPI_ERROR_DEVICE_ERROR) {
+        TEST_ASSERT(((AT_CellularNetwork*)nw)->get_device_error().errCode == 100 && // 100 == unknown command for modem
+                ((AT_CellularNetwork*)nw)->get_device_error().errType == 3); // 3 == CME error from the modem
+    } else {
+        // test for values
+        TEST_ASSERT(rssi >= 0);
+        TEST_ASSERT(ber >= 0);
+    }
+
+    int cell_id = -5;
+    TEST_ASSERT(nw->get_cell_id(cell_id) == NSAPI_ERROR_OK);
+    TEST_ASSERT(cell_id != -5);
+
+    int format = -1;
+    CellularNetwork::operator_t operator_params;
+    // all params are optional so can't test operator_params
+    TEST_ASSERT(nw->get_operator_params(format, operator_params) == NSAPI_ERROR_OK);
+
+    nsapi_connection_status_t st =  nw->get_connection_status();
+    TEST_ASSERT(st == NSAPI_STATUS_DISCONNECTED);
+
+    TEST_ASSERT(nw->set_blocking(true) == NSAPI_ERROR_OK);
+
+#if CELLULAR_DEVICE != QUECTEL_BG96
+    // QUECTEL_BG96 timeouts with this one, tested with 3 minute timeout
+    CellularNetwork::operator_names_list op_names;
+    err = nw->get_operator_names(op_names);
+    TEST_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_DEVICE_ERROR);
+    if (err == NSAPI_ERROR_DEVICE_ERROR) {
+        // if device error then we must check was that really device error or that modem/network does not support the commands
+        TEST_ASSERT(((AT_CellularNetwork*)nw)->get_device_error().errCode == 4// 4 == NOT SUPPORTED BY THE MODEM
+                && ((AT_CellularNetwork*)nw)->get_device_error().errType == 3); // 3 == CME error from the modem
+    } else {
+        CellularNetwork::operator_names_t* opn = op_names.get_head();
+        TEST_ASSERT(strlen(opn->numeric) > 0);
+        TEST_ASSERT(strlen(opn->alpha > 0));
+    }
+#endif
+
+#if CELLULAR_DEVICE != TELIT_HE910
+    // TELIT_HE910 just gives an error and no specific error number so we can't know is this real error or that modem/network does not support the command
+    CellularNetwork::Supported_UE_Opt supported_opt = SUPPORTED_UE_OPT_MAX;
+    CellularNetwork::Preferred_UE_Opt preferred_opt = PREFERRED_UE_OPT_MAX;
+    err = nw->get_ciot_optimization_config(supported_opt, preferred_opt);
+    TEST_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_DEVICE_ERROR);
+    if (err == NSAPI_ERROR_DEVICE_ERROR) {
+        // if device error then we must check was that really device error or that modem/network does not support the commands
+        TEST_ASSERT(((AT_CellularNetwork*)nw)->get_device_error().errCode == 100 && // 100 == unknown command for modem
+                ((AT_CellularNetwork*)nw)->get_device_error().errType == 3); // 3 == CME error from the modem
+    } else {
+        TEST_ASSERT(supported_opt != SUPPORTED_UE_OPT_MAX);
+        TEST_ASSERT(preferred_opt != PREFERRED_UE_OPT_MAX);
+    }
+
+    err = nw->set_ciot_optimization_config(supported_opt, preferred_opt);
+    TEST_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_DEVICE_ERROR);
+    if (err == NSAPI_ERROR_DEVICE_ERROR) {
+        // if device error then we must check was that really device error or that modem/network does not support the commands
+        TEST_ASSERT(((AT_CellularNetwork*)nw)->get_device_error().errCode == 100 && // 100 == unknown command for modem
+                ((AT_CellularNetwork*)nw)->get_device_error().errType == 3); // 3 == CME error from the modem
+    }
+#endif
+
+}
+
+static void test_disconnect()
+{
+    nsapi_connection_status_t st =  nw->get_connection_status();
+    TEST_ASSERT(st == NSAPI_STATUS_GLOBAL_UP);
+    TEST_ASSERT(nw->disconnect() == NSAPI_ERROR_OK);
+}
+
+static void test_detach()
+{
+    // in PPP mode there is NO CARRIER waiting so flush it out
+    rtos::Thread::wait(6*1000);
+    ((AT_CellularNetwork*)nw)->get_at_handler().flush();
+
+    nsapi_connection_status_t st =  nw->get_connection_status();
+    TEST_ASSERT(st == NSAPI_STATUS_DISCONNECTED);
+
+    TEST_ASSERT(nw->detach() == NSAPI_ERROR_OK);
+    st =  nw->get_connection_status();
+    TEST_ASSERT(st == NSAPI_STATUS_DISCONNECTED);
+}
+
+using namespace utest::v1;
+
+static utest::v1::status_t greentea_failure_handler(const Case *const source, const failure_t reason)
+{
+    greentea_case_failure_abort_handler(source, reason);
+    return STATUS_ABORT;
+}
+
+static Case cases[] = {
+    Case("CellularNetwork state machine methods", test_network_interface_fsm, greentea_failure_handler),
+    Case("CellularNetwork init", init_network_interface, greentea_failure_handler),
+    Case("CellularNetwork test registering", test_network_registration, greentea_failure_handler),
+    Case("CellularNetwork test attach", test_attach, greentea_failure_handler),
+    Case("CellularNetwork test activate pdp context", test_activate_context, greentea_failure_handler),
+    Case("CellularNetwork test other functions", test_other, greentea_failure_handler),
+    Case("CellularNetwork test connect", test_connect, greentea_failure_handler),
+    Case("CellularNetwork test credentials", test_credentials, greentea_failure_handler),
+    Case("CellularNetwork test disconnect", test_disconnect, greentea_failure_handler),
+    Case("CellularNetwork test detach", test_detach, greentea_failure_handler)
+
+};
+
+static utest::v1::status_t test_setup(const size_t number_of_cases)
+{
+    GREENTEA_SETUP(10*60, "default_auto");
+    return verbose_test_setup_handler(number_of_cases);
+}
+
+static Specification specification(test_setup, cases);
+
+int main()
+{
+#if MBED_CONF_MBED_TRACE_ENABLE
+    trace_open();
+#endif
+    int ret = Harness::run(specification);
+#if MBED_CONF_MBED_TRACE_ENABLE
+    trace_close();
+#endif
+    return ret;
+}

features/cellular/UNITTESTS/at/at_cellularnetwork/Makefile

@@ -4,7 +4,9 @@ COMPONENT_NAME = AT_CellularNetwork_unit
 
 #This must be changed manually
 SRC_FILES = \
-        ../../../framework/AT/AT_CellularNetwork.cpp
+        ../../../framework/AT/AT_CellularNetwork.cpp \
+        ../../../framework/AT/AT_CellularStack.cpp \
+        ../../../framework/common/CellularUtil.cpp \
 
 TEST_SRC_FILES = \
 	main.cpp \
@@ -15,9 +17,11 @@ TEST_SRC_FILES = \
         ../../stubs/EventQueue_stub.cpp \
         ../../stubs/FileHandle_stub.cpp \
         ../../stubs/NetworkInterface_stub.cpp \
-        ../../stubs/CellularUtil_stub.cpp \
+        ../../stubs/NetworkStack_stub.cpp \
         ../../stubs/us_ticker_stub.cpp \
         ../../stubs/mbed_assert_stub.cpp \
+        ../../stubs/SocketAddress_stub.cpp \
+        ../../stubs/randLIB_stub.cpp \
 
 include ../../MakefileWorker.mk
 

features/cellular/UNITTESTS/at/at_cellularnetwork/at_cellularnetworktest.cpp

@@ -16,6 +16,7 @@
  */
 #include "CppUTest/TestHarness.h"
 #include "test_at_cellularnetwork.h"
+#include "ATHandler_stub.h"
 
 TEST_GROUP(AT_CellularNetwork)
 {
@@ -24,6 +25,9 @@ TEST_GROUP(AT_CellularNetwork)
     void setup()
     {
         unit = new Test_AT_CellularNetwork();
+        ATHandler_stub::int_count = kRead_int_table_size;
+        ATHandler_stub::read_string_index = kRead_string_table_size;
+        ATHandler_stub::resp_stop_success_count = kResp_stop_count_default;
     }
 
     void teardown()
@@ -42,11 +46,21 @@ TEST(AT_CellularNetwork, test_AT_CellularNetwork_constructor)
     unit->test_AT_CellularNetwork_constructor();
 }
 
+TEST(AT_CellularNetwork, test_AT_CellularNetwork_init)
+{
+    unit->test_AT_CellularNetwork_init();
+}
+
 TEST(AT_CellularNetwork, test_AT_CellularNetwork_set_credentials)
 {
     unit->test_AT_CellularNetwork_set_credentials();
 }
 
+TEST(AT_CellularNetwork, test_AT_CellularNetwork_activate_context)
+{
+    unit->test_AT_CellularNetwork_activate_context();
+}
+
 TEST(AT_CellularNetwork, test_AT_CellularNetwork_connect)
 {
     unit->test_AT_CellularNetwork_connect();
@@ -72,6 +86,16 @@ TEST(AT_CellularNetwork, test_AT_CellularNetwork_get_registration_status)
     unit->test_AT_CellularNetwork_get_registration_status();
 }
 
+TEST(AT_CellularNetwork, test_AT_CellularNetwork_get_network_registering_mode)
+{
+    unit->test_AT_CellularNetwork_get_network_registering_mode();
+}
+
+TEST(AT_CellularNetwork, test_AT_CellularNetwork_set_registration_urc)
+{
+    unit->test_AT_CellularNetwork_set_registration_urc();
+}
+
 TEST(AT_CellularNetwork, test_AT_CellularNetwork_set_attach)
 {
     unit->test_AT_CellularNetwork_set_attach();
@@ -107,6 +131,11 @@ TEST(AT_CellularNetwork, test_AT_CellularNetwork_set_access_technology)
     unit->test_AT_CellularNetwork_set_access_technology();
 }
 
+TEST(AT_CellularNetwork, test_AT_CellularNetwork_get_access_technology)
+{
+    unit->test_AT_CellularNetwork_get_access_technology();
+}
+
 TEST(AT_CellularNetwork, test_AT_CellularNetwork_scan_plmn)
 {
     unit->test_AT_CellularNetwork_scan_plmn();
@@ -166,3 +195,19 @@ TEST(AT_CellularNetwork, test_AT_CellularNetwork_get_operator_names)
 {
     unit->test_AT_CellularNetwork_get_operator_names();
 }
+
+TEST(AT_CellularNetwork, test_AT_CellularNetwork_attach)
+{
+    unit->test_AT_CellularNetwork_attach();
+}
+
+TEST(AT_CellularNetwork, test_get_connection_status)
+{
+    unit->test_get_connection_status();
+}
+
+TEST(AT_CellularNetwork, test_set_blocking)
+{
+    unit->test_set_blocking();
+}
+

features/cellular/UNITTESTS/at/at_cellularnetwork/test_at_cellularnetwork.h

@@ -26,8 +26,12 @@ public:
 
     void test_AT_CellularNetwork_constructor();
 
+    void test_AT_CellularNetwork_init();
+
     void test_AT_CellularNetwork_set_credentials();
 
+    void test_AT_CellularNetwork_activate_context();
+
     void test_AT_CellularNetwork_connect();
 
     void test_AT_CellularNetwork_disconnect();
@@ -38,6 +42,10 @@ public:
 
     void test_AT_CellularNetwork_get_registration_status();
 
+    void test_AT_CellularNetwork_get_network_registering_mode();
+
+    void test_AT_CellularNetwork_set_registration_urc();
+
     void test_AT_CellularNetwork_set_attach();
 
     void test_AT_CellularNetwork_get_attach();
@@ -52,6 +60,8 @@ public:
 
     void test_AT_CellularNetwork_set_access_technology();
 
+    void test_AT_CellularNetwork_get_access_technology();
+
     void test_AT_CellularNetwork_scan_plmn();
 
     void test_AT_CellularNetwork_set_ciot_optimization_config();
@@ -75,6 +85,12 @@ public:
     void test_AT_CellularNetwork_get_operator_params();
 
     void test_AT_CellularNetwork_get_operator_names();
+
+    void test_AT_CellularNetwork_attach();
+
+    void test_get_connection_status();
+
+    void test_set_blocking();
 };
 
 #endif // TEST_AT_CELLULARNETWORK_H

features/cellular/UNITTESTS/at/at_cellularsms/test_at_cellularsms.cpp

@@ -57,7 +57,7 @@ void Test_AT_CellularSMS::test_AT_CellularSMS_initialize()
 
     AT_CellularSMS sms(at);
     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
-    CHECK(NSAPI_ERROR_AUTH_FAILURE == sms.initialize(CellularSMS::CellularSMSMmodeText));
+    CHECK(NSAPI_ERROR_NO_MEMORY == sms.initialize(CellularSMS::CellularSMSMmodeText));
 }
 
 

features/cellular/UNITTESTS/stubs/ATHandler_stub.cpp

@@ -45,6 +45,13 @@ FileHandle_stub *ATHandler_stub::fh_value = NULL;
 device_err_t ATHandler_stub::device_err_value;
 Callback<void()> ATHandler_stub::callback = NULL;
 uint8_t ATHandler_stub::resp_info_true_counter = false;
+uint8_t ATHandler_stub::info_elem_true_counter = false;
+int ATHandler_stub::int_valid_count_table[kRead_int_table_size];
+int ATHandler_stub::int_count = kRead_int_table_size;
+
+int ATHandler_stub::read_string_index = kRead_string_table_size;
+char* ATHandler_stub::read_string_table[kRead_string_table_size];
+int ATHandler_stub::resp_stop_success_count = kResp_stop_count_default;
 
 ATHandler::ATHandler(FileHandle *fh, EventQueue &queue, int timeout, const char *output_delimiter, uint16_t send_delay) :
     _nextATHandler(0),
@@ -91,7 +98,7 @@ void ATHandler::set_file_handle(FileHandle *fh)
 nsapi_error_t ATHandler::set_urc_handler(const char *urc, mbed::Callback<void()> cb)
 {
     ATHandler_stub::callback = cb;
-    return NSAPI_ERROR_OK;
+    return ATHandler_stub::nsapi_error_value;
 }
 
 void ATHandler::remove_urc_handler(const char *prefix, mbed::Callback<void()> callback)
@@ -136,6 +143,7 @@ void ATHandler::process_oob()
 
 void ATHandler::clear_error()
 {
+    ATHandler_stub::nsapi_error_ok_counter++;
 }
 
 void ATHandler::skip_param(uint32_t count) {
@@ -153,15 +161,44 @@ ssize_t ATHandler::read_bytes(uint8_t *buf, size_t len)
 
 ssize_t ATHandler::read_string(char *buf, size_t size, bool read_even_stop_tag)
 {
-    if (ATHandler_stub::read_string_value && ATHandler_stub::ssize_value >= 0) {
+
-        memcpy(buf, ATHandler_stub::read_string_value, ATHandler_stub::ssize_value);
+    if (ATHandler_stub::read_string_index == kRead_string_table_size) {
+        if (ATHandler_stub::read_string_value && ATHandler_stub::ssize_value >= 0) {
+            memcpy(buf, ATHandler_stub::read_string_value, ATHandler_stub::ssize_value);
+        }
+        return ATHandler_stub::ssize_value;
     }
-    return ATHandler_stub::ssize_value;
+
+    ATHandler_stub::read_string_index--;
+    if (ATHandler_stub::read_string_index >= 0) {
+        char* tmp = ATHandler_stub::read_string_table[ATHandler_stub::read_string_index];
+        ssize_t len = strlen(tmp);
+        memcpy(buf, tmp, len+1);
+        return len;
+    }
+
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR;
+    return -1;
 }
 
-int ATHandler::read_int()
+int32_t ATHandler::read_int()
 {
-    return ATHandler_stub::int_value;
+    if (ATHandler_stub::nsapi_error_value != NSAPI_ERROR_OK) {
+        return -1;
+    }
+
+    if (ATHandler_stub::int_count == kRead_int_table_size) {
+        return ATHandler_stub::int_value;
+    }
+
+    //printf("ATHandler_stub::int_count: %d", ATHandler_stub::int_count);
+    ATHandler_stub::int_count--;
+    if (ATHandler_stub::int_count < kRead_int_table_size && ATHandler_stub::int_count >= 0) {
+        return ATHandler_stub::int_valid_count_table[ATHandler_stub::int_count];
+    }
+
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR;
+    return -1;
 }
 
 void ATHandler::set_delimiter(char delimiter)
@@ -196,6 +233,10 @@ bool ATHandler::info_resp()
 
 bool ATHandler::info_elem(char start_tag)
 {
+    if (ATHandler_stub::info_elem_true_counter) {
+        ATHandler_stub::info_elem_true_counter--;
+        return true;
+    }
     return ATHandler_stub::bool_value;
 }
 
@@ -206,13 +247,18 @@ bool ATHandler::consume_to_stop_tag()
 
 void ATHandler::resp_stop()
 {
+    if (ATHandler_stub::resp_stop_success_count > 0) {
+        ATHandler_stub::resp_stop_success_count--;
+        return;
+    }
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR;
 }
 
 void ATHandler::cmd_start(const char* cmd)
 {
 }
 
-void ATHandler::write_int(int param)
+void ATHandler::write_int(int32_t param)
 {
 }
 

features/cellular/UNITTESTS/stubs/ATHandler_stub.h

@@ -23,6 +23,9 @@
 #include "FileHandle_stub.h"
 #include "Callback.h"
 
+static const int kRead_string_table_size = 100;
+static const int kRead_int_table_size = 100;
+static const int kResp_stop_count_default = 100;
 
 namespace ATHandler_stub {
     extern nsapi_error_t nsapi_error_value;
@@ -33,13 +36,19 @@ namespace ATHandler_stub {
     extern bool default_timeout;
     extern bool debug_on;
     extern ssize_t ssize_value;
-    extern char* read_string_value;
+    extern char *read_string_value;
     extern size_t size_value;
     extern size_t return_given_size;
     extern bool bool_value;
     extern uint8_t resp_info_true_counter;
+    extern uint8_t info_elem_true_counter;
     extern uint8_t uint8_value;
     extern mbed::FileHandle_stub *fh_value;
     extern mbed::device_err_t device_err_value;
     extern mbed::Callback<void()> callback;
+    extern char *read_string_table[kRead_string_table_size];
+    extern int read_string_index;
+    extern int int_valid_count_table[kRead_int_table_size];
+    extern int int_count;
+    extern int resp_stop_success_count;
 }

features/cellular/UNITTESTS/stubs/AT_CellularBase_stub.cpp

@@ -41,3 +41,7 @@ device_err_t AT_CellularBase::get_device_error() const
     return AT_CellularBase_stub::device_err_value;
 }
 
+bool AT_CellularBase::is_supported(SupportedFeature feature)
+{
+    return true;
+}

features/cellular/UNITTESTS/stubs/AT_CellularInformation_stub.cpp

@@ -42,3 +42,8 @@ nsapi_error_t AT_CellularInformation::get_revision(char *buf, size_t buf_size)
 {
     return 0;
 }
+
+nsapi_error_t AT_CellularInformation::get_serial_number(char *buf, size_t buf_size, SerialNumberType type)
+{
+    return 0;
+}

features/cellular/UNITTESTS/stubs/AT_CellularSIM_stub.cpp

@@ -52,3 +52,8 @@ nsapi_error_t AT_CellularSIM::get_imsi(char* imsi)
 {
     return NSAPI_ERROR_OK;
 }
+
+nsapi_error_t AT_CellularSIM::get_iccid(char *buf, size_t buf_size)
+{
+    return NSAPI_ERROR_OK;
+}

features/cellular/framework/API/CellularPower.h

@@ -92,7 +92,7 @@ public:
      *
      *  @return zero on success
      */
-    virtual nsapi_error_t set_power_level(int func_level, int do_reset = 1) = 0;
+    virtual nsapi_error_t set_power_level(int func_level, int do_reset = 0) = 0;
 
     /** Reset and wake-up cellular device.
      *

features/cellular/framework/AT/AT_CellularNetwork.cpp

@@ -85,24 +85,24 @@ void AT_CellularNetwork::free_credentials()
 {
     if (_uname) {
         free(_uname);
+        _uname = NULL;
     }
 
     if (_pwd) {
         free(_pwd);
+        _pwd = NULL;
     }
 
     if (_apn) {
         free(_apn);
+        _apn = NULL;
     }
 }
 
 void AT_CellularNetwork::urc_no_carrier()
 {
     tr_error("Data call failed: no carrier");
-    _connect_status = NSAPI_STATUS_DISCONNECTED;
+    call_network_cb(NSAPI_STATUS_DISCONNECTED);
-    if (_connection_status_cb) {
-        _connection_status_cb(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_DISCONNECTED);
-    }
 }
 
 void AT_CellularNetwork::read_reg_params_and_compare(RegistrationType type)
@@ -166,6 +166,8 @@ void AT_CellularNetwork::urc_cgreg()
 nsapi_error_t AT_CellularNetwork::set_credentials(const char *apn,
         const char *username, const char *password)
 {
+    free_credentials();
+
     size_t len;
     if (apn && (len = strlen(apn)) > 0) {
         _apn = (char *)malloc(len * sizeof(char) + 1);
@@ -246,7 +248,7 @@ nsapi_error_t AT_CellularNetwork::activate_context()
     nsapi_error_t err = NSAPI_ERROR_OK;
 
     // try to find or create context with suitable stack
-    if(get_context()) {
+    if (get_context()) {
         // try to authenticate user before activating or modifying context
         err = do_user_authentication();
     } else {
@@ -256,11 +258,7 @@ nsapi_error_t AT_CellularNetwork::activate_context()
     if (err != NSAPI_ERROR_OK) {
         _at.unlock();
         tr_error("Failed to activate network context! (%d)", err);
-
+        call_network_cb(NSAPI_STATUS_DISCONNECTED);
-        _connect_status = NSAPI_STATUS_DISCONNECTED;
-        if (_connection_status_cb) {
-            _connection_status_cb(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_DISCONNECTED);
-        }
 
         return err;
     }
@@ -310,21 +308,14 @@ nsapi_error_t AT_CellularNetwork::activate_context()
 
 nsapi_error_t AT_CellularNetwork::connect()
 {
-    _connect_status = NSAPI_STATUS_CONNECTING;
+    call_network_cb(NSAPI_STATUS_CONNECTING);
-    if (_connection_status_cb) {
-        _connection_status_cb(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_CONNECTING);
-    }
 
     nsapi_error_t err = NSAPI_ERROR_OK;
     if (!_is_context_active) {
         err = activate_context();
     }
     if (err) {
-        _connect_status = NSAPI_STATUS_DISCONNECTED;
+        call_network_cb(NSAPI_STATUS_DISCONNECTED);
-        if (_connection_status_cb) {
-            _connection_status_cb(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_DISCONNECTED);
-        }
-
         return err;
     }
 
@@ -334,17 +325,11 @@ nsapi_error_t AT_CellularNetwork::connect()
     _at.unlock();
     if (err != NSAPI_ERROR_OK) {
         tr_error("Failed to open data channel!");
-        _connect_status = NSAPI_STATUS_DISCONNECTED;
+        call_network_cb(NSAPI_STATUS_DISCONNECTED);
-        if (_connection_status_cb) {
-            _connection_status_cb(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_DISCONNECTED);
-        }
         return err;
     }
 #else
-    _connect_status = NSAPI_STATUS_GLOBAL_UP;
+    call_network_cb(NSAPI_STATUS_GLOBAL_UP);
-    if (_connection_status_cb) {
-        _connection_status_cb(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_GLOBAL_UP);
-    }
 #endif
 
     return NSAPI_ERROR_OK;
@@ -401,15 +386,22 @@ nsapi_error_t AT_CellularNetwork::disconnect()
     _at.resp_stop();
     _at.restore_at_timeout();
 
-    _connect_status = NSAPI_STATUS_DISCONNECTED;
+    call_network_cb(NSAPI_STATUS_DISCONNECTED);
-    if (_connection_status_cb) {
-        _connection_status_cb(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_DISCONNECTED);
-    }
 
     return _at.unlock_return_error();
 #endif
 }
 
+void AT_CellularNetwork::call_network_cb(nsapi_connection_status_t status)
+{
+    if (_connect_status != status) {
+        _connect_status = status;
+        if (_connection_status_cb) {
+            _connection_status_cb(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, _connect_status);
+        }
+    }
+}
+
 void AT_CellularNetwork::attach(Callback<void(nsapi_event_t, intptr_t)> status_cb)
 {
     _connection_status_cb = status_cb;
@@ -575,6 +567,7 @@ bool AT_CellularNetwork::get_context()
                             break;
                         }
                     } else {
+                        // requested dual stack or stack is not specified
                         // If dual PDP need to check for IPV4 or IPV6 modem support. Prefer IPv6.
                         if (pdp_stack == IPV4V6_STACK) {
                             if (modem_supports_ipv6) {
@@ -829,6 +822,8 @@ nsapi_error_t AT_CellularNetwork::detach()
     _at.resp_start();
     _at.resp_stop();
 
+    call_network_cb(NSAPI_STATUS_DISCONNECTED);
+
     return _at.unlock_return_error();
 }
 
@@ -1048,10 +1043,8 @@ nsapi_error_t AT_CellularNetwork::get_rate_control(
         }
     }
     _at.resp_stop();
-    nsapi_error_t ret = _at.get_last_error();
-    _at.unlock();
 
-    return (ret == NSAPI_ERROR_OK) ? NSAPI_ERROR_OK : NSAPI_ERROR_PARAMETER;
+    return _at.unlock_return_error();
 }
 
 nsapi_error_t AT_CellularNetwork::get_pdpcontext_params(pdpContextList_t &params_list)

features/cellular/framework/AT/AT_CellularNetwork.h

@@ -162,7 +162,8 @@ private:
 
     void read_reg_params_and_compare(RegistrationType type);
     void read_reg_params(RegistrationType type, RegistrationStatus &reg_status, int &lac, int &cell_id, int &act);
-
+    // calls network callback only if status was changed, updates local connection status
+    void call_network_cb(nsapi_connection_status_t status);
 #if NSAPI_PPP_AVAILABLE
     void ppp_status_cb(nsapi_event_t, intptr_t);
 #endif

features/cellular/framework/AT/AT_CellularPower.h

@@ -41,7 +41,7 @@ public:
 
     virtual nsapi_error_t set_at_mode();
 
-    virtual nsapi_error_t set_power_level(int func_level, int do_reset = 1);
+    virtual nsapi_error_t set_power_level(int func_level, int do_reset = 0);
 
     virtual nsapi_error_t reset();