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

more unittests added

pull/6082/head
Antti Kauppila 2018-02-12 16:44:36 +02:00 committed by Ari Parkkila
parent bf3d587571
commit bfbd3e42af
12 changed files with 518 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
features/cellular/UNITTESTS/at/at_cellularpower/test_at_cellularpower.cpp
View File

@ -9,13 +9,14 @@
#include "ATHandler.h"
#include "AT_CellularPower.h"
#include "FileHandle_stub.h"
#include "ATHandler_stub.h"
using namespace mbed;
using namespace events;
Test_AT_CellularPower::Test_AT_CellularPower()
{
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
}
Test_AT_CellularPower::~Test_AT_CellularPower()
@ -35,35 +36,90 @@ void Test_AT_CellularPower::test_AT_CellularPower_constructor()
void Test_AT_CellularPower::test_AT_CellularPower_on()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularPower pow(at);
CHECK(NSAPI_ERROR_UNSUPPORTED == pow.on())
}
void Test_AT_CellularPower::test_AT_CellularPower_off()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularPower pow(at);
CHECK(NSAPI_ERROR_UNSUPPORTED == pow.off())
}
void Test_AT_CellularPower::test_AT_CellularPower_set_at_mode()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularPower pow(at);
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.set_at_mode())
}
void Test_AT_CellularPower::test_AT_CellularPower_set_power_level()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularPower pow(at);
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.set_power_level(6));
}
void Test_AT_CellularPower::test_AT_CellularPower_reset()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularPower pow(at);
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.reset());
}
void Test_AT_CellularPower::test_AT_CellularPower_opt_power_save_mode()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularPower pow(at);
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.opt_power_save_mode(0,0));
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.opt_power_save_mode(10,0));
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.opt_power_save_mode(912,0));
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.opt_power_save_mode(1834,1834));
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.opt_power_save_mode(18345,18345));
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.opt_power_save_mode(101234,101234));
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.opt_power_save_mode(1012345,1012345));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
CHECK(NSAPI_ERROR_OK == pow.opt_power_save_mode(39612345,39612345));
}
void Test_AT_CellularPower::test_AT_CellularPower_opt_receive_period()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularPower pow(at);
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.opt_receive_period(1, CellularPower::EDRXUTRAN_Iu_mode, 3));
}

65
features/cellular/UNITTESTS/at/at_cellularsim/test_at_cellularsim.cpp
View File

@ -10,6 +10,7 @@
#include "AT_CellularSIM.h"
#include "FileHandle_stub.h"
#include "CellularLog.h"
#include "ATHandler_stub.h"
using namespace mbed;
using namespace events;
@ -18,7 +19,9 @@ uint32_t mbed::cellular_log_time = 0;
Test_AT_CellularSIM::Test_AT_CellularSIM()
{
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
ATHandler_stub::read_string_value = NULL;
ATHandler_stub::ssize_value = 0;
}
Test_AT_CellularSIM::~Test_AT_CellularSIM()
@ -38,20 +41,80 @@ void Test_AT_CellularSIM::test_AT_CellularSIM_constructor()
void Test_AT_CellularSIM::test_AT_CellularSIM_set_pin()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularSIM sim(at);
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.set_pin("12"));
char table2[] = "READY";
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
ATHandler_stub::read_string_value = table2;
ATHandler_stub::ssize_value = 5;
CHECK(NSAPI_ERROR_OK == sim.set_pin("12"));
}
void Test_AT_CellularSIM::test_AT_CellularSIM_change_pin()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularSIM sim(at);
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.change_pin("12", "34"));
}
void Test_AT_CellularSIM::test_AT_CellularSIM_set_pin_query()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularSIM sim(at);
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.set_pin_query("12", true));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.set_pin_query("12", false));
}
void Test_AT_CellularSIM::test_AT_CellularSIM_get_sim_state()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularSIM sim(at);
CellularSIM::SimState state;
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
ATHandler_stub::ssize_value = -1;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.get_sim_state(state));
CHECK(CellularSIM::SimStateUnknown == state);
char table2[] = "READY";
ATHandler_stub::read_string_value = table2;
ATHandler_stub::ssize_value = 5;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.get_sim_state(state));
CHECK(CellularSIM::SimStateReady == state);
char table3[] = "SIM PIN";
ATHandler_stub::read_string_value = table3;
ATHandler_stub::ssize_value = 7;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.get_sim_state(state));
CHECK(CellularSIM::SimStatePinNeeded == state);
char table4[] = "SIM PUK";
ATHandler_stub::read_string_value = table4;
ATHandler_stub::ssize_value = 7;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.get_sim_state(state));
CHECK(CellularSIM::SimStatePukNeeded == state);
char table5[] = "SOME CRAP";
ATHandler_stub::read_string_value = table5;
ATHandler_stub::ssize_value = 9;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.get_sim_state(state));
CHECK(CellularSIM::SimStateUnknown == state);
}

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

@ -7,6 +7,7 @@
#include "AT_CellularNetwork.h"
#include "EventQueue.h"
#include "ATHandler.h"
#include "ATHandler_stub.h"
#include "AT_CellularSMS.h"
#include "FileHandle_stub.h"
#include "CellularLog.h"
@ -18,7 +19,8 @@ uint32_t mbed::cellular_log_time = 0;
Test_AT_CellularSMS::Test_AT_CellularSMS()
{
ATHandler_stub::return_given_size = false;
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
}
Test_AT_CellularSMS::~Test_AT_CellularSMS()
@ -36,47 +38,159 @@ void Test_AT_CellularSMS::test_AT_CellularSMS_constructor()
delete sms;
}
void Test_AT_CellularSMS::test_AT_CellularSMS_initialize(){
void Test_AT_CellularSMS::test_AT_CellularSMS_initialize()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularSMS sms(at);
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sms.initialize(CellularSMS::CellularSMSMmodeText));
}
void Test_AT_CellularSMS::test_AT_CellularSMS_send_sms(){
void Test_AT_CellularSMS::test_AT_CellularSMS_send_sms()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularSMS sms(at);
CHECK(NSAPI_ERROR_PARAMETER == sms.send_sms(NULL, "2", 1));
sms.initialize(CellularSMS::CellularSMSMmodeText);
ATHandler_stub::size_value = 1;
CHECK(1 == sms.send_sms("1", "22", 2));
ATHandler_stub::size_value = 2;
CHECK(2 == sms.send_sms("1", "22", 2));
sms.initialize(CellularSMS::CellularSMSMmodePDU);
CHECK(2 == sms.send_sms("1", "23", 2));
ATHandler_stub::nsapi_error_ok_counter = 1;
ATHandler_stub::size_value = 32;
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sms.send_sms("1", "23232323", 8));
ATHandler_stub::nsapi_error_ok_counter = 2;
ATHandler_stub::size_value = 32;
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sms.send_sms("1", "23232323", 8));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
char table[] = "232323232323232323232323232323232323232323232323232323\
232323232323232323232323232323232323232323232323232323\
232323232323232323232323232323232323232323232323232323\
23232323232323232323232323232323232323\0";
ATHandler_stub::size_value = 0;
ATHandler_stub::return_given_size = true;
CHECK(218 == sms.send_sms("1", table, strlen(table)));
CHECK(218 == sms.send_sms("12", table, strlen(table)));
}
void Test_AT_CellularSMS::test_AT_CellularSMS_get_sms(){
void Test_AT_CellularSMS::test_AT_CellularSMS_get_sms()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularSMS sms(at);
char buf[16];
char phone[21];
char stamp[21];
int size;
CHECK(NSAPI_ERROR_PARAMETER == sms.get_sms(NULL, 16, phone, 21, stamp, 21, &size));
ATHandler_stub::resp_info_true_counter = 1;
ATHandler_stub::int_value = 0;
CHECK(-1 == sms.get_sms(buf, 16, phone, 21, stamp, 21, &size));
ATHandler_stub::resp_info_true_counter = 2;
ATHandler_stub::int_value = 11;
CHECK(0 == sms.get_sms(buf, 16, phone, 21, stamp, 21, &size));
//TODO: Should make add_info to happen, before calling get_sms!
ATHandler_stub::resp_info_true_counter = 2;
ATHandler_stub::int_value = 11;
sms.initialize(CellularSMS::CellularSMSMmodePDU);
CHECK(0 == sms.get_sms(buf, 16, phone, 21, stamp, 21, &size));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sms.get_sms(buf, 16, phone, 21, stamp, 21, &size));
}
void Test_AT_CellularSMS::test_AT_CellularSMS_set_sms_callback(){
void Test_AT_CellularSMS::test_AT_CellularSMS_set_sms_callback()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularSMS sms(at);
sms.set_sms_callback(NULL);
}
void Test_AT_CellularSMS::test_AT_CellularSMS_set_cpms(){
void Test_AT_CellularSMS::test_AT_CellularSMS_set_cpms()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularSMS sms(at);
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sms.set_cpms("2", "3", "4"));
}
void Test_AT_CellularSMS::test_AT_CellularSMS_set_csca(){
void Test_AT_CellularSMS::test_AT_CellularSMS_set_csca()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularSMS sms(at);
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sms.set_csca("2", 1));
}
void Test_AT_CellularSMS::test_AT_CellularSMS_set_cscs(){
void Test_AT_CellularSMS::test_AT_CellularSMS_set_cscs()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularSMS sms(at);
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sms.set_cscs("2"));
}
void Test_AT_CellularSMS::test_AT_CellularSMS_delete_all_messages(){
void Test_AT_CellularSMS::test_AT_CellularSMS_delete_all_messages()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularSMS sms(at);
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sms.delete_all_messages());
}
void Test_AT_CellularSMS::test_AT_CellularSMS_set_extra_sim_wait_time(){
void Test_AT_CellularSMS::test_AT_CellularSMS_set_extra_sim_wait_time()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
AT_CellularSMS sms(at);
sms.set_extra_sim_wait_time(56);
}

187
features/cellular/UNITTESTS/at/at_cellularstack/test_at_cellularstack.cpp
View File

@ -10,6 +10,8 @@
#include "AT_CellularStack.h"
#include "FileHandle_stub.h"
#include "CellularLog.h"
#include "ATHandler_stub.h"
#include "SocketAddress.h"
using namespace mbed;
using namespace events;
@ -18,17 +20,28 @@ uint32_t mbed::cellular_log_time = 0;
class MyStack : public AT_CellularStack {
public:
MyStack(ATHandler &atr, int cid, nsapi_ip_stack_t typ) : AT_CellularStack(atr, cid, typ){}
bool bool_value;
bool max_sock_value;
nsapi_error_t create_error;
int max_packet_size;
virtual int get_max_socket_count(){return 0;}
MyStack(ATHandler &atr, int cid, nsapi_ip_stack_t typ) : AT_CellularStack(atr, cid, typ)
{
bool_value = false;
max_sock_value = 0;
create_error = NSAPI_ERROR_OK;
max_packet_size = 0;
}
virtual int get_max_packet_size(){return 0;}
virtual int get_max_socket_count(){return max_sock_value;}
virtual bool is_protocol_supported(nsapi_protocol_t protocol){return false;}
virtual int get_max_packet_size(){return max_packet_size;}
virtual bool is_protocol_supported(nsapi_protocol_t protocol){return bool_value;}
virtual nsapi_error_t socket_close_impl(int sock_id){return NSAPI_ERROR_OK;}
virtual nsapi_error_t create_socket_impl(CellularSocket *socket){return NSAPI_ERROR_OK;}
virtual nsapi_error_t create_socket_impl(CellularSocket *socket){return create_error;}
virtual nsapi_size_or_error_t socket_sendto_impl(CellularSocket *socket, const SocketAddress &address,
const void *data, nsapi_size_t size){return NSAPI_ERROR_OK;}
@ -39,7 +52,9 @@ public:
Test_AT_CellularStack::Test_AT_CellularStack()
{
ATHandler_stub::ssize_value = 0;
ATHandler_stub::bool_value = false;
ATHandler_stub::read_string_value = NULL;
}
Test_AT_CellularStack::~Test_AT_CellularStack()
@ -59,60 +74,214 @@ void Test_AT_CellularStack::test_AT_CellularStack_constructor()
void Test_AT_CellularStack::test_AT_CellularStack_get_ip_address()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
MyStack st(at, 0, IPV6_STACK);
CHECK(0 == strlen(st.get_ip_address()));
char table[] = "1.2.3.4.5.65.7.8.9.10.11\0";
ATHandler_stub::ssize_value = -1;
ATHandler_stub::bool_value = true;
ATHandler_stub::read_string_value = table;
CHECK(NULL == st.get_ip_address());
ATHandler_stub::ssize_value = strlen(table);
ATHandler_stub::bool_value = true;
ATHandler_stub::read_string_value = table;
CHECK(st.get_ip_address());
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_open()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
MyStack st(at, 0, IPV6_STACK);
st.bool_value = false;
CHECK(NSAPI_ERROR_UNSUPPORTED == st.socket_open(NULL, NSAPI_TCP));
st.bool_value = true;
st.max_sock_value = 0;
nsapi_socket_t sock;
CHECK(NSAPI_ERROR_NO_SOCKET == st.socket_open(&sock, NSAPI_TCP));
MyStack st2(at, 0, IPV6_STACK);
st2.bool_value = true;
st2.max_sock_value = 1;
nsapi_socket_t sock2;
CHECK(NSAPI_ERROR_OK == st2.socket_open(&sock2, NSAPI_TCP));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_close()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
MyStack st(at, 0, IPV6_STACK);
nsapi_socket_t soc = NULL;
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_close(soc));
st.bool_value = true;
st.max_sock_value = 1;
nsapi_socket_t sock;
CHECK(NSAPI_ERROR_OK == st.socket_open(&sock, NSAPI_TCP));
st.max_sock_value = 0;
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_close(sock));
MyStack st2(at, 0, IPV6_STACK);
st2.max_sock_value = 1;
st2.bool_value = true;
nsapi_socket_t sock2;
CHECK(NSAPI_ERROR_OK == st2.socket_open(&sock2, NSAPI_TCP));
CHECK(NSAPI_ERROR_OK == st2.socket_close(sock2));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_bind()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
MyStack st(at, 0, IPV6_STACK);
nsapi_socket_t sock;
SocketAddress addr;
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_ALREADY;
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_bind(NULL, addr));
CHECK(NSAPI_ERROR_ALREADY == st.socket_bind(sock, addr));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_listen()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
MyStack st(at, 0, IPV6_STACK);
nsapi_socket_t sock;
CHECK(0 == st.socket_listen(sock, 4));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_connect()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
MyStack st(at, 0, IPV6_STACK);
SocketAddress addr;
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_connect(NULL, addr));
nsapi_socket_t sock;
CHECK(NSAPI_ERROR_OK == st.socket_connect(sock, addr));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_accept()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
MyStack st(at, 0, IPV6_STACK);
nsapi_socket_t sock;
CHECK(0 == st.socket_accept(NULL, &sock));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_send()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
}
MyStack st(at, 0, IPV6_STACK);
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_send(NULL, "addr", 4));
void Test_AT_CellularStack::test_AT_CellularStack_socket_recv()
{
nsapi_socket_t sock;
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_send(sock, "addr", 4));
SocketAddress addr;
st.max_sock_value = 1;
st.bool_value = true;
st.socket_open(&sock, NSAPI_TCP);
st.socket_connect(sock, addr);
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_send(sock, "addr", 4));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_sendto()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
MyStack st(at, 0, IPV6_STACK);
nsapi_socket_t sock;
SocketAddress addr;
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_sendto(NULL, addr, "addr", 4));
st.max_sock_value = 1;
st.bool_value = true;
st.socket_open(&sock, NSAPI_TCP);
st.socket_connect(sock, addr);
st.create_error = NSAPI_ERROR_CONNECTION_LOST;
CHECK(NSAPI_ERROR_CONNECTION_LOST == st.socket_sendto(sock, addr, "addr", 4));
st.create_error = NSAPI_ERROR_OK;
st.max_packet_size = 6;
CHECK(NSAPI_ERROR_OK == st.socket_sendto(sock, addr, "addr", 4));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_recv()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
MyStack st(at, 0, IPV6_STACK);
char table[4];
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_recv(NULL, table, 4));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_recvfrom()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
MyStack st(at, 0, IPV6_STACK);
char table[4];
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_recvfrom(NULL, NULL, table, 4));
nsapi_socket_t sock;
SocketAddress addr;
st.max_sock_value = 1;
st.bool_value = true;
st.socket_open(&sock, NSAPI_TCP);
st.socket_connect(sock, addr);
st.create_error = NSAPI_ERROR_CONNECTION_LOST;
CHECK(NSAPI_ERROR_CONNECTION_LOST == st.socket_recvfrom(sock, &addr, table, 4));
st.create_error = NSAPI_ERROR_OK;
st.max_packet_size = 6;
CHECK(NSAPI_ERROR_OK == st.socket_recvfrom(sock, &addr, table, 4));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_attach()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0);
MyStack st(at, 0, IPV6_STACK);
st.socket_attach(NULL, NULL, NULL);
nsapi_socket_t sock;
st.max_sock_value = 1;
st.bool_value = true;
st.socket_open(&sock, NSAPI_TCP);
st.socket_attach(sock, NULL, NULL);
}

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

@ -29,14 +29,18 @@ using namespace events;
const int DEFAULT_AT_TIMEOUT = 1000; // at default timeout in milliseconds
nsapi_error_t ATHandler_stub::nsapi_error_value = 0;
uint8_t ATHandler_stub::nsapi_error_ok_counter = 0;
int ATHandler_stub::int_value = -1;
ssize_t ATHandler_stub::ssize_value = 0;
char* ATHandler_stub::read_string_value = NULL;
size_t ATHandler_stub::size_value = 0;
size_t ATHandler_stub::return_given_size = false;
bool ATHandler_stub::bool_value = false;
uint8_t ATHandler_stub::uint8_value = 0;
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;
ATHandler::ATHandler(FileHandle *fh, EventQueue &queue, int timeout, const char *output_delimiter) :
_nextATHandler(0),
@ -82,6 +86,10 @@ void ATHandler::set_urc_handler(const char *urc, mbed::Callback<void()> cb)
nsapi_error_t ATHandler::get_last_error() const
{
if (ATHandler_stub::nsapi_error_ok_counter) {
ATHandler_stub::nsapi_error_ok_counter--;
return NSAPI_ERROR_OK;
}
return ATHandler_stub::nsapi_error_value;
}
@ -129,6 +137,9 @@ 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);
}
return ATHandler_stub::ssize_value;
}
@ -156,6 +167,10 @@ void ATHandler::resp_start(const char *prefix, bool stop)
bool ATHandler::info_resp()
{
if (ATHandler_stub::resp_info_true_counter) {
ATHandler_stub::resp_info_true_counter--;
return true;
}
return ATHandler_stub::bool_value;
}
@ -187,6 +202,9 @@ void ATHandler::write_string(const char* param, bool useQuotations)
size_t ATHandler::write_bytes(uint8_t* param, size_t len)
{
if (ATHandler_stub::return_given_size) {
return len;
}
return ATHandler_stub::size_value;
}

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

@ -26,10 +26,14 @@
namespace ATHandler_stub {
extern nsapi_error_t nsapi_error_value;
extern uint8_t nsapi_error_ok_counter;
extern int int_value;
extern ssize_t ssize_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 uint8_value;
extern mbed::FileHandle_stub *fh_value;
extern mbed::device_err_t device_err_value;

8
features/cellular/UNITTESTS/stubs/AT_CellularSMS_stub.cpp
View File

@ -109,10 +109,10 @@ nsapi_size_or_error_t AT_CellularSMS::set_cscs(const char *chr_set)
return NSAPI_ERROR_OK;
}
nsapi_error_t AT_CellularSMS::set_csms(int msg_service)
{
return NSAPI_ERROR_OK;
}
//nsapi_error_t AT_CellularSMS::set_csms(int msg_service)
//{
// return NSAPI_ERROR_OK;
//}
nsapi_error_t AT_CellularSMS::delete_sms(sms_info_t* sms)
{

63
features/cellular/UNITTESTS/stubs/CellularUtil_stub.cpp
View File

@ -43,51 +43,7 @@ uint16_t char_str_to_hex(const char* str, uint16_t len, char *buf, bool omit_lea
void convert_ipv6(char* ip)
{
if (!ip) {
return;
}
int len = strlen(ip);
int pos = 0;
int i;
for (i = 0; i < len; i++) {
if (ip[i] == '.') {
pos++;
}
if (pos > 3) {
break;
}
}
// more that 3 periods mean that it was ipv6 but in format of a1.a2.a3.a4.a5.a6.a7.a8.a9.a10.a11.a12.a13.a14.a15.a16
// we need to convert it to hexadecimal format separated with colons
if (pos > 3) {
pos = 0;
int ip_pos = 0;
char b;
bool set_colon = false;
for (i = 0; i < len; i++) {
if (ip[i] == '.') {
b = (char)strtol (ip+ip_pos, NULL, 10); // convert to char to int so we can change it to hex string
pos += char_str_to_hex(&b, 1, ip+pos, !set_colon); // omit leading zeroes with using set_colon flag
if (set_colon) {
ip[pos++] = ':';
set_colon = false;
} else {
set_colon = true;
}
ip_pos = i+1; // skip the '.'
}
// handle the last part which does not end with '.' but '\0'
if (i == len -1) {
b = (char)strtol(ip+ip_pos, NULL, 10);
pos += char_str_to_hex(&b, 1, ip+pos, !set_colon);
ip[pos] = '\0';
}
}
}
}
char* find_dot_number(char* str, int dot_number)
@ -109,7 +65,8 @@ void prefer_ipv6(char* ip, size_t ip_size, char* ip2, size_t ip2_size)
void int_to_hex_str(uint8_t num, char* buf)
{
buf[0] = '0';
buf[1] = '2';
}
int hex_str_to_int(const char *hex_string, int hex_string_length)
@ -129,7 +86,23 @@ void uint_to_binary_str(uint32_t num, char* str, int str_size, int bit_cnt)
int char_str_to_hex_str(const char* str, uint16_t len, char *buf, bool omit_leading_zero)
{
//The code is dependent on this, so this is easiest just to put here
if (!str || !buf) {
return 0;
}
char *ptr = buf;
int i=0;
while (i < len) {
if (omit_leading_zero == true && i == 0 && !(str[i]>>4 & 0x0F)) {
*ptr++ = hex_values[(str[i]) & 0x0F];
} else {
*ptr++ = hex_values[((str[i])>>4) & 0x0F];
*ptr++ = hex_values[(str[i]) & 0x0F];
}
i++;
}
return ptr-buf;
}
uint16_t get_dynamic_ip_port()

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

@ -18,6 +18,8 @@
#include "AT_CellularPower.h"
#include "CellularUtil.h"
#include "CellularLog.h"
#include "nsapi_types.h"
#include "ATHandler_stub.h"
static const int PSMTimerBits = 5;

22
features/cellular/framework/AT/AT_CellularSMS.cpp
View File

@ -513,6 +513,7 @@ nsapi_size_or_error_t AT_CellularSMS::send_sms(const char* phone_number, const c
_at.cmd_stop();
_at.unlock();
free(pdu_str);
//TODO: Fix this (might be bigger value than msg_len!)
return write_size;
}
@ -534,6 +535,7 @@ nsapi_size_or_error_t AT_CellularSMS::send_sms(const char* phone_number, const c
nsapi_error_t ret = _at.get_last_error();
_at.unlock();
//TODO: fix this also: msg_len should be returned instead of write_size!
return (ret == NSAPI_ERROR_OK) ? write_size : ret;
}
@ -581,17 +583,17 @@ nsapi_size_or_error_t AT_CellularSMS::set_cscs(const char *chr_set)
return _at.unlock_return_error();
}
nsapi_error_t AT_CellularSMS::set_csms(int msg_service)
{
_at.lock();
_at.cmd_start("AT+CSMS=");
_at.write_int(msg_service);
_at.cmd_stop();
_at.resp_start();
_at.resp_stop();
//nsapi_error_t AT_CellularSMS::set_csms(int msg_service)
//{
// _at.lock();
// _at.cmd_start("AT+CSMS=");
// _at.write_int(msg_service);
// _at.cmd_stop();
// _at.resp_start();
// _at.resp_stop();
return _at.unlock_return_error();
}
// return _at.unlock_return_error();
//}
nsapi_error_t AT_CellularSMS::delete_sms(sms_info_t* sms)
{

14
features/cellular/framework/AT/AT_CellularSMS.h
View File

@ -158,13 +158,13 @@ private:
*/
nsapi_error_t set_cmgf(int msg_format);
/** Select message service (AT+CSMS select message service)
*
* @param msg_service 0 or 1. See more from 3GPP TS 27.005
*
* @return zero for success
*/
nsapi_error_t set_csms(int msg_service);
// /** Select message service (AT+CSMS select message service)
// *
// * @param msg_service 0 or 1. See more from 3GPP TS 27.005
// *
// * @return zero for success
// */
// nsapi_error_t set_csms(int msg_service);
/* Set how receiving of new messages from the network is indicated to the TE.
*

32
features/cellular/framework/AT/AT_CellularStack.cpp
View File

@ -24,6 +24,7 @@ using namespace mbed;
AT_CellularStack::AT_CellularStack(ATHandler &at, int cid, nsapi_ip_stack_t stack_type) : AT_CellularBase(at), _socket(NULL),_socket_count(0),_cid(cid), _stack_type(stack_type)
{
memset(_ip,0, PDP_IPV6_SIZE);
}
AT_CellularStack::~AT_CellularStack()
@ -31,10 +32,13 @@ AT_CellularStack::~AT_CellularStack()
for (int i = 0; i < _socket_count; i++) {
if (_socket[i]) {
delete _socket[i];
_socket[i] = NULL;
}
}
_socket_count = 0;
delete [] _socket;
_socket = NULL;
}
/** NetworkStack
@ -79,7 +83,7 @@ const char * AT_CellularStack::get_ip_address()
nsapi_error_t AT_CellularStack::socket_open(nsapi_socket_t *handle, nsapi_protocol_t proto)
{
if (!is_protocol_supported(proto)) {
if (!is_protocol_supported(proto) || !handle) {
return NSAPI_ERROR_UNSUPPORTED;
}
@ -127,6 +131,9 @@ nsapi_error_t AT_CellularStack::socket_close(nsapi_socket_t handle)
int err = NSAPI_ERROR_DEVICE_ERROR;
struct CellularSocket *socket = (struct CellularSocket *)handle;
if (!socket){
return err;
}
int sock_id = socket->id;
int max_socket_count = get_max_socket_count();
@ -138,10 +145,11 @@ nsapi_error_t AT_CellularStack::socket_close(nsapi_socket_t handle)
}
}
if (index != -1) {
if (index == -1) {
return err;
}
_socket[index] = NULL;
err = NSAPI_ERROR_OK;
}
_at.lock();
@ -152,6 +160,7 @@ nsapi_error_t AT_CellularStack::socket_close(nsapi_socket_t handle)
_at.unlock();
delete socket;
socket = NULL;
return err;
}
@ -159,6 +168,9 @@ nsapi_error_t AT_CellularStack::socket_close(nsapi_socket_t handle)
nsapi_error_t AT_CellularStack::socket_bind(nsapi_socket_t handle, const SocketAddress &addr)
{
struct CellularSocket *socket = (CellularSocket *)handle;
if (!socket) {
return NSAPI_ERROR_DEVICE_ERROR;
}
socket->localAddress = addr;
_at.lock();
@ -178,6 +190,9 @@ nsapi_error_t AT_CellularStack::socket_listen(nsapi_socket_t handle, int backlog
nsapi_error_t AT_CellularStack::socket_connect(nsapi_socket_t handle, const SocketAddress &addr)
{
CellularSocket *socket = (CellularSocket *)handle;
if (!socket) {
return NSAPI_ERROR_DEVICE_ERROR;
}
socket->remoteAddress = addr;
socket->connected = true;
@ -192,7 +207,7 @@ nsapi_error_t AT_CellularStack::socket_accept(void *server, void **socket, Socke
nsapi_size_or_error_t AT_CellularStack::socket_send(nsapi_socket_t handle, const void *data, unsigned size)
{
CellularSocket *socket = (CellularSocket *)handle;
if (!socket->connected) {
if (!socket || !socket->connected) {
return NSAPI_ERROR_DEVICE_ERROR;
}
return socket_sendto(handle, socket->remoteAddress, data, size);
@ -201,6 +216,9 @@ nsapi_size_or_error_t AT_CellularStack::socket_send(nsapi_socket_t handle, const
nsapi_size_or_error_t AT_CellularStack::socket_sendto(nsapi_socket_t handle, const SocketAddress &addr, const void *data, unsigned size)
{
CellularSocket *socket = (CellularSocket *)handle;
if (!socket) {
return NSAPI_ERROR_DEVICE_ERROR;
}
nsapi_size_or_error_t ret_val = NSAPI_ERROR_OK;
@ -240,6 +258,9 @@ nsapi_size_or_error_t AT_CellularStack::socket_recv(nsapi_socket_t handle, void
nsapi_size_or_error_t AT_CellularStack::socket_recvfrom(nsapi_socket_t handle, SocketAddress *addr, void *buffer, unsigned size)
{
CellularSocket *socket = (CellularSocket *)handle;
if (!socket) {
return NSAPI_ERROR_DEVICE_ERROR;
}
nsapi_size_or_error_t ret_val = NSAPI_ERROR_OK;
@ -273,6 +294,9 @@ nsapi_size_or_error_t AT_CellularStack::socket_recvfrom(nsapi_socket_t handle, S
void AT_CellularStack::socket_attach(nsapi_socket_t handle, void (*callback)(void *), void *data)
{
CellularSocket *socket = (CellularSocket *)handle;
if (!socket) {
return;
}
socket->_cb = callback;
socket->_data = data;
}