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

Cellular: updated unit tests.

pull/7273/head
Teppo Järvelin 2018-06-20 13:10:34 +03:00
parent f3424da060
commit 4bd4042101
11 changed files with 206 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
features/cellular/UNITTESTS/at/at_cellularbase/at_cellularbasetest.cpp
View File

@ -48,3 +48,12 @@ TEST(AT_CellularBase, test_AT_CellularBase_get_device_error)
unit->test_AT_CellularBase_get_device_error();
}
TEST(AT_CellularBase, test_AT_CellularBase_set_unsupported_features)
{
unit->test_AT_CellularBase_set_unsupported_features();
}
TEST(AT_CellularBase, test_AT_CellularBase_is_supported)
{
unit->test_AT_CellularBase_is_supported();
}

56
features/cellular/UNITTESTS/at/at_cellularbase/test_at_cellularbase.cpp
View File

@ -25,6 +25,34 @@
using namespace mbed;
using namespace events;
class my_base : public AT_CellularBase {
public:
my_base(ATHandler &at) : AT_CellularBase(at) {
}
bool check_not_supported() {
static const AT_CellularBase::SupportedFeature unsupported_features[] = {
AT_CellularBase::AT_CGSN_WITH_TYPE,
AT_CellularBase::SUPPORTED_FEATURE_END_MARK
};
set_unsupported_features(unsupported_features);
return is_supported(AT_CGSN_WITH_TYPE);
}
bool check_supported() {
set_unsupported_features(NULL);
return is_supported(AT_CGSN_WITH_TYPE);
}
bool check_supported_not_found() {
static const AT_CellularBase::SupportedFeature unsupported_features[] = {
AT_CellularBase::AT_CGSN_WITH_TYPE,
AT_CellularBase::SUPPORTED_FEATURE_END_MARK
};
set_unsupported_features(unsupported_features);
return is_supported(SUPPORTED_FEATURE_END_MARK);
}
};
Test_AT_CellularBase::Test_AT_CellularBase()
{
@ -57,3 +85,31 @@ void Test_AT_CellularBase::test_AT_CellularBase_get_device_error()
ATHandler_stub::device_err_value.errCode = 0;
}
void Test_AT_CellularBase::test_AT_CellularBase_set_unsupported_features()
{
EventQueue eq;
FileHandle_stub fh;
ATHandler ah(&fh, eq, 0, ",");
AT_CellularBase at(ah);
static const AT_CellularBase::SupportedFeature unsupported_features[] = {
AT_CellularBase::AT_CGSN_WITH_TYPE,
AT_CellularBase::SUPPORTED_FEATURE_END_MARK
};
at.set_unsupported_features(unsupported_features);
}
void Test_AT_CellularBase::test_AT_CellularBase_is_supported()
{
EventQueue eq;
FileHandle_stub fh;
ATHandler ah(&fh, eq, 0, ",");
my_base my_at(ah);
CHECK(true == my_at.check_supported());
CHECK(true == my_at.check_supported_not_found());
CHECK(false == my_at.check_not_supported());
}

4
features/cellular/UNITTESTS/at/at_cellularbase/test_at_cellularbase.h
View File

@ -27,6 +27,10 @@ public:
void test_AT_CellularBase_get_at_handler();
void test_AT_CellularBase_get_device_error();
void test_AT_CellularBase_set_unsupported_features();
void test_AT_CellularBase_is_supported();
};
#endif // TEST_AT_CELLULARBASE_H

5
features/cellular/UNITTESTS/at/at_cellulardevice/at_cellulardevicetest.cpp
View File

@ -111,3 +111,8 @@ TEST(AT_CellularDevice, test_AT_CellularDevice_get_stack)
{
unit->test_AT_CellularDevice_get_stack();
}
TEST(AT_CellularDevice, test_AT_CellularDevice_get_send_delay)
{
unit->test_AT_CellularDevice_get_send_delay();
}

19
features/cellular/UNITTESTS/at/at_cellulardevice/test_at_cellulardevice.cpp
View File

@ -50,12 +50,12 @@ void Test_AT_CellularDevice::test_AT_CellularDevice_get_at_handler()
FileHandle_stub fh2;
FileHandle_stub fh3;
dev.open_network(&fh1);
dev.open_sms(&fh2);
CHECK(dev.open_network(&fh1));
CHECK(dev.open_sms(&fh2));
AT_CellularBase_stub::handler_value = AT_CellularBase_stub::handler_at_constructor_value;
dev.open_sim(&fh3);
CHECK(dev.open_sim(&fh3));
ATHandler_stub::fh_value = &fh1;
dev.open_power(&fh1);
CHECK(dev.open_power(&fh1));
ATHandler_stub::fh_value = NULL;
}
@ -121,6 +121,7 @@ void Test_AT_CellularDevice::test_AT_CellularDevice_close_network()
CHECK(ATHandler_stub::ref_count == 1);
dev.close_network();
CHECK(ATHandler_stub::ref_count == 0);
}
void Test_AT_CellularDevice::test_AT_CellularDevice_close_sms()
@ -134,6 +135,7 @@ void Test_AT_CellularDevice::test_AT_CellularDevice_close_sms()
CHECK(ATHandler_stub::ref_count == 1);
dev.close_sms();
CHECK(ATHandler_stub::ref_count == 0);
}
void Test_AT_CellularDevice::test_AT_CellularDevice_close_power()
@ -147,6 +149,7 @@ void Test_AT_CellularDevice::test_AT_CellularDevice_close_power()
CHECK(ATHandler_stub::ref_count == 1);
dev.close_power();
CHECK(ATHandler_stub::ref_count == 0);
}
void Test_AT_CellularDevice::test_AT_CellularDevice_close_sim()
@ -162,6 +165,7 @@ void Test_AT_CellularDevice::test_AT_CellularDevice_close_sim()
CHECK(ATHandler_stub::ref_count == 1);
dev.close_sim();
CHECK(ATHandler_stub::ref_count == 0);
}
void Test_AT_CellularDevice::test_AT_CellularDevice_close_information()
@ -212,6 +216,13 @@ void Test_AT_CellularDevice::test_AT_CellularDevice_set_timeout()
dev.close_sim();
}
void Test_AT_CellularDevice::test_AT_CellularDevice_get_send_delay()
{
EventQueue que;
AT_CellularDevice dev(que);
CHECK(0 == dev.get_send_delay());
}
void Test_AT_CellularDevice::test_AT_CellularDevice_modem_debug_on()
{
EventQueue que;

2
features/cellular/UNITTESTS/at/at_cellulardevice/test_at_cellulardevice.h
View File

@ -53,6 +53,8 @@ public:
void test_AT_CellularDevice_modem_debug_on();
void test_AT_CellularDevice_get_stack();
void test_AT_CellularDevice_get_send_delay();
};
#endif // TEST_AT_CELLULARDEVICE_H

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

@ -74,8 +74,11 @@ void Test_AT_CellularPower::test_AT_CellularPower_set_at_mode()
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());
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
CHECK(NSAPI_ERROR_OK == pow.set_at_mode());
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR;
CHECK(NSAPI_ERROR_DEVICE_ERROR == pow.set_at_mode());
}
void Test_AT_CellularPower::test_AT_CellularPower_set_power_level()
@ -85,10 +88,13 @@ void Test_AT_CellularPower::test_AT_CellularPower_set_power_level()
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));
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.set_power_level(1,1));
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.set_power_level(1,0));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
CHECK(NSAPI_ERROR_OK == pow.set_power_level(6));
CHECK(NSAPI_ERROR_OK == pow.set_power_level(1,1));
CHECK(NSAPI_ERROR_OK == pow.set_power_level(1,0));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR;
CHECK(NSAPI_ERROR_DEVICE_ERROR == pow.set_power_level(6));
}
void Test_AT_CellularPower::test_AT_CellularPower_reset()
@ -98,8 +104,11 @@ void Test_AT_CellularPower::test_AT_CellularPower_reset()
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());
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
CHECK(NSAPI_ERROR_OK == pow.reset());
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR;
CHECK(NSAPI_ERROR_DEVICE_ERROR == pow.reset());
}
void Test_AT_CellularPower::test_AT_CellularPower_opt_power_save_mode()
@ -109,23 +118,25 @@ void Test_AT_CellularPower::test_AT_CellularPower_opt_power_save_mode()
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(0,0));
CHECK(NSAPI_ERROR_OK == pow.opt_power_save_mode(10,0));
CHECK(NSAPI_ERROR_OK == pow.opt_power_save_mode(912,0));
CHECK(NSAPI_ERROR_OK == pow.opt_power_save_mode(1834,1834));
CHECK(NSAPI_ERROR_OK == pow.opt_power_save_mode(18345,18345));
CHECK(NSAPI_ERROR_OK == pow.opt_power_save_mode(101234,101234));
CHECK(NSAPI_ERROR_OK == pow.opt_power_save_mode(1012345,1012345));
CHECK(NSAPI_ERROR_OK == pow.opt_power_save_mode(39612345,39612345));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR;
CHECK(NSAPI_ERROR_DEVICE_ERROR == pow.opt_power_save_mode(0,0));
}
void Test_AT_CellularPower::test_AT_CellularPower_opt_receive_period()
@ -135,8 +146,11 @@ void Test_AT_CellularPower::test_AT_CellularPower_opt_receive_period()
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));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
CHECK(NSAPI_ERROR_OK == pow.opt_receive_period(1, CellularPower::EDRXUTRAN_Iu_mode, 3));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR;
CHECK(NSAPI_ERROR_DEVICE_ERROR == pow.opt_receive_period(1, CellularPower::EDRXUTRAN_Iu_mode, 3));
}
void Test_AT_CellularPower::test_AT_CellularPower_is_device_ready()
@ -162,6 +176,7 @@ void Test_AT_CellularPower::test_AT_CellularPower_set_device_ready_urc_cb()
AT_CellularPower pow(at);
CHECK(NSAPI_ERROR_UNSUPPORTED == pow.set_device_ready_urc_cb(&device_ready_cb));
CHECK(NSAPI_ERROR_UNSUPPORTED == pow.set_device_ready_urc_cb(NULL));
}
void Test_AT_CellularPower::test_AT_CellularPower_remove_device_ready_urc_cb()

6
features/cellular/UNITTESTS/at/at_cellularsim/at_cellularsimtest.cpp
View File

@ -16,6 +16,7 @@
*/
#include "CppUTest/TestHarness.h"
#include "test_at_cellularsim.h"
#include "ATHandler_stub.h"
TEST_GROUP(AT_CellularSIM)
{
@ -24,6 +25,7 @@ TEST_GROUP(AT_CellularSIM)
void setup()
{
unit = new Test_AT_CellularSIM();
ATHandler_stub::read_string_index = kRead_string_table_size;
}
void teardown()
@ -67,3 +69,7 @@ TEST(AT_CellularSIM, test_AT_CellularSIM_get_imsi)
unit->test_AT_CellularSIM_get_imsi();
}
TEST(AT_CellularSIM, test_AT_CellularSIM_get_iccid)
{
unit->test_AT_CellularSIM_get_iccid();
}

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

@ -57,12 +57,14 @@ void Test_AT_CellularSIM::test_AT_CellularSIM_set_pin()
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;
CHECK(NSAPI_ERROR_OK == sim.set_pin("12"));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR;
CHECK(NSAPI_ERROR_DEVICE_ERROR == sim.set_pin("12"));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
ATHandler_stub::read_string_value = "READY";
ATHandler_stub::ssize_value = 5;
CHECK(NSAPI_ERROR_OK == sim.set_pin("12"));
@ -76,12 +78,14 @@ void Test_AT_CellularSIM::test_AT_CellularSIM_change_pin()
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"));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
CHECK(NSAPI_ERROR_OK == sim.change_pin("12", "34"));
CHECK(NSAPI_ERROR_OK == sim.change_pin(NULL, "34"));
CHECK(NSAPI_ERROR_OK == sim.change_pin("12", NULL));
CHECK(NSAPI_ERROR_OK == sim.change_pin(NULL, NULL));
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.change_pin(NULL, "34"));
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.change_pin("12", NULL));
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.change_pin(NULL, NULL));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR;
CHECK(NSAPI_ERROR_DEVICE_ERROR == sim.change_pin("12", "34"));
}
void Test_AT_CellularSIM::test_AT_CellularSIM_set_pin_query()
@ -91,13 +95,17 @@ void Test_AT_CellularSIM::test_AT_CellularSIM_set_pin_query()
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));
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.set_pin_query(NULL, true));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
CHECK(NSAPI_ERROR_OK == sim.set_pin_query("12", true));
CHECK(NSAPI_ERROR_OK == sim.set_pin_query(NULL, true));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.set_pin_query("12", false));
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.set_pin_query(NULL, false));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
CHECK(NSAPI_ERROR_OK == sim.set_pin_query("12", false));
CHECK(NSAPI_ERROR_OK == sim.set_pin_query(NULL, false));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR;
CHECK(NSAPI_ERROR_DEVICE_ERROR == sim.set_pin_query("12", false));
CHECK(NSAPI_ERROR_DEVICE_ERROR == sim.set_pin_query("12", true));
}
void Test_AT_CellularSIM::test_AT_CellularSIM_get_sim_state()
@ -108,33 +116,30 @@ void Test_AT_CellularSIM::test_AT_CellularSIM_get_sim_state()
AT_CellularSIM sim(at);
CellularSIM::SimState state;
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
ATHandler_stub::ssize_value = -1;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.get_sim_state(state));
ATHandler_stub::read_string_value = NULL;
CHECK(NSAPI_ERROR_OK == sim.get_sim_state(state));
CHECK(CellularSIM::SimStateUnknown == state);
char table2[] = "READY";
ATHandler_stub::read_string_value = table2;
ATHandler_stub::read_string_value = "READY";
ATHandler_stub::ssize_value = 5;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.get_sim_state(state));
CHECK(NSAPI_ERROR_OK == sim.get_sim_state(state));
CHECK(CellularSIM::SimStateReady == state);
char table3[] = "SIM PIN";
ATHandler_stub::read_string_value = table3;
ATHandler_stub::read_string_value = "SIM PIN";
ATHandler_stub::ssize_value = 7;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.get_sim_state(state));
CHECK(NSAPI_ERROR_OK == sim.get_sim_state(state));
CHECK(CellularSIM::SimStatePinNeeded == state);
char table4[] = "SIM PUK";
ATHandler_stub::read_string_value = table4;
ATHandler_stub::read_string_value = "SIM PUK";
ATHandler_stub::ssize_value = 7;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.get_sim_state(state));
CHECK(NSAPI_ERROR_OK == sim.get_sim_state(state));
CHECK(CellularSIM::SimStatePukNeeded == state);
char table5[] = "SOME CRAP";
ATHandler_stub::read_string_value = table5;
ATHandler_stub::read_string_value = "SOME CRAP";
ATHandler_stub::ssize_value = 9;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.get_sim_state(state));
CHECK(NSAPI_ERROR_OK == sim.get_sim_state(state));
CHECK(CellularSIM::SimStateUnknown == state);
}
@ -152,6 +157,13 @@ void Test_AT_CellularSIM::test_AT_CellularSIM_get_imsi()
CHECK(NSAPI_ERROR_OK == sim.get_imsi(imsi));
CHECK(strcmp(ATHandler_stub::read_string_value, imsi) == 0);
ATHandler_stub::read_string_value = NULL;
ATHandler_stub::ssize_value = -1;
ATHandler_stub::read_string_index = -1;
imsi[0] = 0;
CHECK(NSAPI_ERROR_DEVICE_ERROR == sim.get_imsi(imsi));
CHECK(strlen(imsi) == 0);
CHECK(NSAPI_ERROR_PARAMETER == sim.get_imsi(NULL));
// this would fail as get_imsi should take another param which is the size of the buffer which we could use for validation.
@ -159,3 +171,25 @@ void Test_AT_CellularSIM::test_AT_CellularSIM_get_imsi()
//char imsi2[5];
//CHECK(NSAPI_ERROR_PARAMETER == sim.get_imsi(imsi2));
}
void Test_AT_CellularSIM::test_AT_CellularSIM_get_iccid()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
char buf[16];
AT_CellularSIM sim(at);
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
ATHandler_stub::read_string_value = "123456789012345";
ATHandler_stub::ssize_value = 15;
CHECK(NSAPI_ERROR_OK == sim.get_iccid(buf, 16));
CHECK(strcmp(ATHandler_stub::read_string_value, buf) == 0);
buf[0] = 0;
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR;
ATHandler_stub::read_string_value = NULL;
ATHandler_stub::ssize_value = -1;
CHECK(NSAPI_ERROR_DEVICE_ERROR == sim.get_iccid(buf, 16));
CHECK(strlen(buf) == 0);
}

2
features/cellular/UNITTESTS/at/at_cellularsim/test_at_cellularsim.h
View File

@ -35,6 +35,8 @@ public:
void test_AT_CellularSIM_get_sim_state();
void test_AT_CellularSIM_get_imsi();
void test_AT_CellularSIM_get_iccid();
};
#endif // TEST_AT_CELLULARSIM_H

6
features/cellular/UNITTESTS/run_tests
View File

@ -34,9 +34,9 @@ lcov -q -r app.info "/UNITTESTS/*" -o app.info $branch_cov
lcov -q -r app.info "/UNITTESTS/stubs*" -o app.info $branch_cov
lcov -q -r app.info "/UNITTESTS/target_h*" -o app.info $branch_cov
lcov -q -r app.info "/mbed-client*" -o app.info $branch_cov
lcov -q -r app.info "/mbed-os/events*" -o app.info $branch_cov
lcov -q -r app.info "/mbed-os/features/netsocket*" -o app.info $branch_cov
lcov -q -r app.info "/mbed-os/platform*" -o app.info $branch_cov
lcov -q -r app.info "/events*" -o app.info $branch_cov
lcov -q -r app.info "/features/netsocket*" -o app.info $branch_cov
lcov -q -r app.info "/platform*" -o app.info $branch_cov
genhtml $branch_data app.info
cd ..
echo