ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #7269 from jarvte/add_cellular_network_tests 

Cellular: add cellular network tests
pull/7113/merge
Cruz Monrreal 2018-06-25 10:05:20 -05:00 committed by GitHub
parent 8e170ccbd1 1fb4d2dfc9
commit 335fd58a7c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 1401 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

418
features/cellular/TESTS/api/cellular_network/main.cpp Normal file
View File

@ -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;
}

8
features/cellular/UNITTESTS/at/at_cellularnetwork/Makefile
View File

@ -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

45
features/cellular/UNITTESTS/at/at_cellularnetwork/at_cellularnetworktest.cpp
View File

@ -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();
}

853
features/cellular/UNITTESTS/at/at_cellularnetwork/test_at_cellularnetwork.cpp
View File

File diff suppressed because it is too large Load Diff

16
features/cellular/UNITTESTS/at/at_cellularnetwork/test_at_cellularnetwork.h
View File

@ -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

2
features/cellular/UNITTESTS/at/at_cellularsms/test_at_cellularsms.cpp
View File

@ -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));
}

60
features/cellular/UNITTESTS/stubs/ATHandler_stub.cpp
View File

@ -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)
{
}

11
features/cellular/UNITTESTS/stubs/ATHandler_stub.h
View File

@ -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;
}

4
features/cellular/UNITTESTS/stubs/AT_CellularBase_stub.cpp
View File

@ -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;
}

5
features/cellular/UNITTESTS/stubs/AT_CellularInformation_stub.cpp
View File

@ -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;
}

5
features/cellular/UNITTESTS/stubs/AT_CellularSIM_stub.cpp
View File

@ -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;
}

2
features/cellular/framework/API/CellularPower.h
View File

@ -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.
*

61
features/cellular/framework/AT/AT_CellularNetwork.cpp
View File

@ -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;
if (_connection_status_cb) {
_connection_status_cb(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_DISCONNECTED);
}
call_network_cb(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);
_connect_status = NSAPI_STATUS_DISCONNECTED;
if (_connection_status_cb) {
_connection_status_cb(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_DISCONNECTED);
}
call_network_cb(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;
if (_connection_status_cb) {
_connection_status_cb(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_CONNECTING);
}
call_network_cb(NSAPI_STATUS_CONNECTING);
nsapi_error_t err = NSAPI_ERROR_OK;
if (!_is_context_active) {
err = activate_context();
}
if (err) {
_connect_status = NSAPI_STATUS_DISCONNECTED;
if (_connection_status_cb) {
_connection_status_cb(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_DISCONNECTED);
}
call_network_cb(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;
if (_connection_status_cb) {
_connection_status_cb(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_DISCONNECTED);
}
call_network_cb(NSAPI_STATUS_DISCONNECTED);
return err;
}
#else
_connect_status = NSAPI_STATUS_GLOBAL_UP;
if (_connection_status_cb) {
_connection_status_cb(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_GLOBAL_UP);
}
call_network_cb(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;
if (_connection_status_cb) {
_connection_status_cb(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_DISCONNECTED);
}
call_network_cb(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)

3
features/cellular/framework/AT/AT_CellularNetwork.h
View File

@ -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

2
features/cellular/framework/AT/AT_CellularPower.h
View File

@ -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();