From bfbd3e42af01a8bd738be43912e9fe11717c5b9d Mon Sep 17 00:00:00 2001 From: Antti Kauppila Date: Mon, 12 Feb 2018 16:44:36 +0200 Subject: [PATCH] more unittests added --- .../test_at_cellularpower.cpp | 58 +++++- .../at/at_cellularsim/test_at_cellularsim.cpp | 65 +++++- .../at/at_cellularsms/test_at_cellularsms.cpp | 134 ++++++++++++- .../test_at_cellularstack.cpp | 187 +++++++++++++++++- .../UNITTESTS/stubs/ATHandler_stub.cpp | 18 ++ .../cellular/UNITTESTS/stubs/ATHandler_stub.h | 4 + .../UNITTESTS/stubs/AT_CellularSMS_stub.cpp | 8 +- .../UNITTESTS/stubs/CellularUtil_stub.cpp | 65 ++---- .../framework/AT/AT_CellularPower.cpp | 2 + .../cellular/framework/AT/AT_CellularSMS.cpp | 22 ++- .../cellular/framework/AT/AT_CellularSMS.h | 14 +- .../framework/AT/AT_CellularStack.cpp | 34 +++- 12 files changed, 518 insertions(+), 93 deletions(-) diff --git a/features/cellular/UNITTESTS/at/at_cellularpower/test_at_cellularpower.cpp b/features/cellular/UNITTESTS/at/at_cellularpower/test_at_cellularpower.cpp index 3bbc536fc3..ea85e34c51 100644 --- a/features/cellular/UNITTESTS/at/at_cellularpower/test_at_cellularpower.cpp +++ b/features/cellular/UNITTESTS/at/at_cellularpower/test_at_cellularpower.cpp @@ -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)); } diff --git a/features/cellular/UNITTESTS/at/at_cellularsim/test_at_cellularsim.cpp b/features/cellular/UNITTESTS/at/at_cellularsim/test_at_cellularsim.cpp index caf62a9ea5..121d4d373f 100644 --- a/features/cellular/UNITTESTS/at/at_cellularsim/test_at_cellularsim.cpp +++ b/features/cellular/UNITTESTS/at/at_cellularsim/test_at_cellularsim.cpp @@ -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); } diff --git a/features/cellular/UNITTESTS/at/at_cellularsms/test_at_cellularsms.cpp b/features/cellular/UNITTESTS/at/at_cellularsms/test_at_cellularsms.cpp index f7945e1385..5990105366 100644 --- a/features/cellular/UNITTESTS/at/at_cellularsms/test_at_cellularsms.cpp +++ b/features/cellular/UNITTESTS/at/at_cellularsms/test_at_cellularsms.cpp @@ -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); } diff --git a/features/cellular/UNITTESTS/at/at_cellularstack/test_at_cellularstack.cpp b/features/cellular/UNITTESTS/at/at_cellularstack/test_at_cellularstack.cpp index 908f5f4836..8ce50c5d52 100644 --- a/features/cellular/UNITTESTS/at/at_cellularstack/test_at_cellularstack.cpp +++ b/features/cellular/UNITTESTS/at/at_cellularstack/test_at_cellularstack.cpp @@ -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); } diff --git a/features/cellular/UNITTESTS/stubs/ATHandler_stub.cpp b/features/cellular/UNITTESTS/stubs/ATHandler_stub.cpp index f504bb909f..50f3210080 100644 --- a/features/cellular/UNITTESTS/stubs/ATHandler_stub.cpp +++ b/features/cellular/UNITTESTS/stubs/ATHandler_stub.cpp @@ -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 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 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; } diff --git a/features/cellular/UNITTESTS/stubs/ATHandler_stub.h b/features/cellular/UNITTESTS/stubs/ATHandler_stub.h index 66da3ef303..72fd269583 100644 --- a/features/cellular/UNITTESTS/stubs/ATHandler_stub.h +++ b/features/cellular/UNITTESTS/stubs/ATHandler_stub.h @@ -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; diff --git a/features/cellular/UNITTESTS/stubs/AT_CellularSMS_stub.cpp b/features/cellular/UNITTESTS/stubs/AT_CellularSMS_stub.cpp index d270b7ce92..55fa33684a 100644 --- a/features/cellular/UNITTESTS/stubs/AT_CellularSMS_stub.cpp +++ b/features/cellular/UNITTESTS/stubs/AT_CellularSMS_stub.cpp @@ -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) { diff --git a/features/cellular/UNITTESTS/stubs/CellularUtil_stub.cpp b/features/cellular/UNITTESTS/stubs/CellularUtil_stub.cpp index 2f67da9a06..d6c9a1658f 100644 --- a/features/cellular/UNITTESTS/stubs/CellularUtil_stub.cpp +++ b/features/cellular/UNITTESTS/stubs/CellularUtil_stub.cpp @@ -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) { - return 0; + //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() diff --git a/features/cellular/framework/AT/AT_CellularPower.cpp b/features/cellular/framework/AT/AT_CellularPower.cpp index 9202ace38a..65c7937ea7 100644 --- a/features/cellular/framework/AT/AT_CellularPower.cpp +++ b/features/cellular/framework/AT/AT_CellularPower.cpp @@ -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; diff --git a/features/cellular/framework/AT/AT_CellularSMS.cpp b/features/cellular/framework/AT/AT_CellularSMS.cpp index 73bcd26868..81b586d536 100644 --- a/features/cellular/framework/AT/AT_CellularSMS.cpp +++ b/features/cellular/framework/AT/AT_CellularSMS.cpp @@ -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) { diff --git a/features/cellular/framework/AT/AT_CellularSMS.h b/features/cellular/framework/AT/AT_CellularSMS.h index 5747514926..0cbd164262 100644 --- a/features/cellular/framework/AT/AT_CellularSMS.h +++ b/features/cellular/framework/AT/AT_CellularSMS.h @@ -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. * diff --git a/features/cellular/framework/AT/AT_CellularStack.cpp b/features/cellular/framework/AT/AT_CellularStack.cpp index 068a20408e..c3c0b25e77 100644 --- a/features/cellular/framework/AT/AT_CellularStack.cpp +++ b/features/cellular/framework/AT/AT_CellularStack.cpp @@ -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) { - _socket[index] = NULL; - err = NSAPI_ERROR_OK; + 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; }