Cellular: updated unit tests.

features/cellular/UNITTESTS/at/at_cellularbase/at_cellularbasetest.cpp

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

features/cellular/UNITTESTS/at/at_cellularbase/test_at_cellularbase.cpp

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

features/cellular/UNITTESTS/at/at_cellularbase/test_at_cellularbase.h

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

features/cellular/UNITTESTS/at/at_cellulardevice/at_cellulardevicetest.cpp

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

features/cellular/UNITTESTS/at/at_cellulardevice/test_at_cellulardevice.cpp

@@ -50,12 +50,12 @@ void Test_AT_CellularDevice::test_AT_CellularDevice_get_at_handler()
     FileHandle_stub fh2;
     FileHandle_stub fh3;
 
-    dev.open_network(&fh1);
+    CHECK(dev.open_network(&fh1));
-    dev.open_sms(&fh2);
+    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;

features/cellular/UNITTESTS/at/at_cellulardevice/test_at_cellulardevice.h

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

features/cellular/UNITTESTS/at/at_cellularpower/test_at_cellularpower.cpp

@@ -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;
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
-    CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.set_at_mode());
+    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;
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
-    CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.set_power_level(6));
+    CHECK(NSAPI_ERROR_OK == pow.set_power_level(6));
-    CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.set_power_level(1,1));
+    CHECK(NSAPI_ERROR_OK == pow.set_power_level(1,1));
-    CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.set_power_level(1,0));
+    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;
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
-    CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.reset());
+    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;
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
-    CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.opt_receive_period(1, CellularPower::EDRXUTRAN_Iu_mode, 3));
+    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()

features/cellular/UNITTESTS/at/at_cellularsim/at_cellularsimtest.cpp

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

features/cellular/UNITTESTS/at/at_cellularsim/test_at_cellularsim.cpp

@@ -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;
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
-    CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.change_pin("12", "34"));
+    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"));
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR;
-    CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.change_pin("12", NULL));
+    CHECK(NSAPI_ERROR_DEVICE_ERROR == sim.change_pin("12", "34"));
-    CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.change_pin(NULL, NULL));
 }
 
 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;
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
-    CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.set_pin_query("12", true));
+    CHECK(NSAPI_ERROR_OK == sim.set_pin_query("12", true));
-    CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.set_pin_query(NULL, true));
+    CHECK(NSAPI_ERROR_OK == sim.set_pin_query(NULL, true));
 
-    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
-    CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.set_pin_query("12", false));
+    CHECK(NSAPI_ERROR_OK == sim.set_pin_query("12", false));
-    CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.set_pin_query(NULL, 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 = "READY";
-    ATHandler_stub::read_string_value = table2;
     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 = "SIM PIN";
-    ATHandler_stub::read_string_value = table3;
     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 = "SIM PUK";
-    ATHandler_stub::read_string_value = table4;
     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 = "SOME CRAP";
-    ATHandler_stub::read_string_value = table5;
     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);
+}

features/cellular/UNITTESTS/at/at_cellularsim/test_at_cellularsim.h

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

features/cellular/UNITTESTS/run_tests

@@ -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 "/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 "/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 "/platform*" -o app.info $branch_cov
 genhtml $branch_data app.info
 cd ..
 echo