Add cellular information tests

features/cellular/TESTS/api/cellular_information/main.cpp

@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2018, Arm Limited and affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#if !defined(MBED_CONF_NSAPI_PRESENT)
+#error [NOT_SUPPORTED] A json configuration file is needed. Skipping this build.
+#endif
+
+#include "CellularUtil.h" // for CELLULAR_ helper macros
+#include "CellularTargets.h"
+
+#ifndef CELLULAR_DEVICE
+#error [NOT_SUPPORTED] CELLULAR_DEVICE must be defined
+#endif
+
+#ifndef MBED_CONF_APP_CELLULAR_SIM_PIN
+#error [NOT_SUPPORTED] SIM pin code is needed. Skipping this build.
+#endif
+
+#include "greentea-client/test_env.h"
+#include "unity.h"
+#include "utest.h"
+
+#include "mbed.h"
+
+#include "CellularConnectionFSM.h"
+#include "CellularDevice.h"
+#include "../../cellular_tests_common.h"
+
+#define SIM_TIMEOUT (180*1000)
+
+static UARTSerial cellular_serial(MDMTXD, MDMRXD, MBED_CONF_PLATFORM_DEFAULT_SERIAL_BAUD_RATE);
+static EventQueue queue(2 * EVENTS_EVENT_SIZE);
+static CellularConnectionFSM cellular;
+static CellularConnectionFSM::CellularState cellular_target_state;
+static rtos::Semaphore fsm_semaphore(0);
+
+static bool fsm_callback(int state, int next_state)
+{
+    if (next_state == CellularConnectionFSM::STATE_SIM_PIN) {
+        TEST_ASSERT(fsm_semaphore.release() == osOK);
+        return false;
+    }
+    return true;
+}
+
+static void init_to_sim_state()
+{
+    cellular.set_serial(&cellular_serial);
+    TEST_ASSERT(cellular.init() == NSAPI_ERROR_OK);
+#if defined (MDMRTS) && defined (MDMCTS)
+    cellular_serial.set_flow_control(SerialBase::RTSCTS, MDMRTS, MDMCTS);
+#endif
+    cellular.set_callback(&fsm_callback);
+    TEST_ASSERT(cellular.start_dispatch() == NSAPI_ERROR_OK);
+    cellular_target_state = CellularConnectionFSM::STATE_SIM_PIN;
+    TEST_ASSERT(cellular.continue_to_state(cellular_target_state) == NSAPI_ERROR_OK);
+    TEST_ASSERT(fsm_semaphore.wait(SIM_TIMEOUT) == 1);
+}
+
+static void test_information_interface()
+{
+    CellularInformation *info = cellular.get_device()->open_information(&cellular_serial);
+    const int kbuf_size = 100;
+    char *buf = (char*)malloc(sizeof(char) * kbuf_size);
+
+    TEST_ASSERT(info->get_manufacturer(buf, kbuf_size) == NSAPI_ERROR_OK);
+    TEST_ASSERT(info->get_model(buf, kbuf_size) == NSAPI_ERROR_OK);
+    TEST_ASSERT(info->get_revision(buf, kbuf_size) == NSAPI_ERROR_OK);
+    TEST_ASSERT(info->get_serial_number(buf, kbuf_size, CellularInformation::SN) == NSAPI_ERROR_OK);
+
+    nsapi_error_t err = info->get_serial_number(buf, kbuf_size, CellularInformation::IMEI);
+    TEST_ASSERT(err == NSAPI_ERROR_UNSUPPORTED || err == NSAPI_ERROR_OK);
+
+    err = info->get_serial_number(buf, kbuf_size, CellularInformation::IMEISV);
+    TEST_ASSERT(err == NSAPI_ERROR_UNSUPPORTED || err == NSAPI_ERROR_OK);
+
+    err = info->get_serial_number(buf, kbuf_size, CellularInformation::SVN);
+    TEST_ASSERT(err == NSAPI_ERROR_UNSUPPORTED || err == NSAPI_ERROR_OK);
+
+    cellular.get_device()->close_information();
+
+    free(buf);
+}
+
+using namespace utest::v1;
+
+static utest::v1::status_t greentea_failure_handler(const Case *const source, const failure_t reason)
+{
+    greentea_case_failure_abort_handler(source, reason);
+    return STATUS_ABORT;
+}
+
+static Case cases[] = {
+    Case("CellularInformation init", init_to_sim_state, greentea_failure_handler),
+    Case("CellularInformation test interface", test_information_interface, greentea_failure_handler)
+};
+
+static utest::v1::status_t test_setup(const size_t number_of_cases)
+{
+    GREENTEA_SETUP(10*60, "default_auto");
+    return verbose_test_setup_handler(number_of_cases);
+}
+
+static Specification specification(test_setup, cases);
+
+int main()
+{
+#if MBED_CONF_MBED_TRACE_ENABLE
+    trace_open();
+#endif
+    int ret = Harness::run(specification);
+#if MBED_CONF_MBED_TRACE_ENABLE
+    trace_close();
+#endif
+    return ret;
+}

features/cellular/TESTS/api/cellular_power/main.cpp

@@ -54,17 +54,17 @@ static void urc_callback()
 static void wait_for_power(CellularPower* pwr)
 {
     nsapi_error_t err = pwr->set_device_ready_urc_cb(&urc_callback);
-    MBED_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_UNSUPPORTED);
+    TEST_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_UNSUPPORTED);
 
     int sanity_count = 0;
     while (pwr->is_device_ready() != NSAPI_ERROR_OK) {
         sanity_count++;
         wait(1);
-        MBED_ASSERT(sanity_count < 20);
+        TEST_ASSERT(sanity_count < 20);
     }
 
     err = pwr->set_at_mode();
-    MBED_ASSERT(err == NSAPI_ERROR_OK);
+    TEST_ASSERT(err == NSAPI_ERROR_OK);
 
     pwr->remove_device_ready_urc_cb(&urc_callback);
 }
@@ -75,17 +75,17 @@ static void test_power_interface()
     CellularPower* pwr = cellular_device->open_power(&cellular_serial);
 
     nsapi_error_t err = pwr->on();
-    MBED_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_UNSUPPORTED);
+    TEST_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_UNSUPPORTED);
     wait_for_power(pwr);
 
-    MBED_ASSERT(pwr->set_power_level(1,0) == NSAPI_ERROR_OK);
+    TEST_ASSERT(pwr->set_power_level(1,0) == NSAPI_ERROR_OK);
 
     err = pwr->reset();
-    MBED_ASSERT(err == NSAPI_ERROR_OK);
+    TEST_ASSERT(err == NSAPI_ERROR_OK);
     wait_for_power(pwr);
 
     err = pwr->off();
-    MBED_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_UNSUPPORTED);
+    TEST_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_UNSUPPORTED);
 }
 
 using namespace utest::v1;

features/cellular/TESTS/api/cellular_sim/main.cpp

@@ -67,7 +67,7 @@ static char *get_rand_string(char *str, size_t size)
 static bool fsm_callback(int state, int next_state)
 {
     if (next_state == CellularConnectionFSM::STATE_SIM_PIN) {
-        MBED_ASSERT(network_semaphore.release() == osOK);
+        TEST_ASSERT(network_semaphore.release() == osOK);
         return false;
     }
     return true;
@@ -106,27 +106,27 @@ static void test_sim_interface()
 
     // change pin and change it back
     err = sim->change_pin(MBED_CONF_APP_CELLULAR_SIM_PIN, pin);
-    MBED_ASSERT(err == NSAPI_ERROR_OK);
+    TEST_ASSERT(err == NSAPI_ERROR_OK);
     err = sim->change_pin(pin, MBED_CONF_APP_CELLULAR_SIM_PIN);
-    MBED_ASSERT(err == NSAPI_ERROR_OK);
+    TEST_ASSERT(err == NSAPI_ERROR_OK);
 
     // 3. test set_pin_query
     err = sim->set_pin_query(MBED_CONF_APP_CELLULAR_SIM_PIN, false);
-    MBED_ASSERT(err == NSAPI_ERROR_OK);
+    TEST_ASSERT(err == NSAPI_ERROR_OK);
     err = sim->set_pin_query(MBED_CONF_APP_CELLULAR_SIM_PIN, true);
-    MBED_ASSERT(err == NSAPI_ERROR_OK);
+    TEST_ASSERT(err == NSAPI_ERROR_OK);
 
     // 4. test get_sim_state
     CellularSIM::SimState state;
     err = sim->get_sim_state(state);
-    MBED_ASSERT(err == NSAPI_ERROR_OK);
-    MBED_ASSERT(state == CellularSIM::SimStateReady);
+    TEST_ASSERT(err == NSAPI_ERROR_OK);
+    TEST_ASSERT(state == CellularSIM::SimStateReady);
 
     // 5. test get_imsi
     char imsi[16] = {0};
     err = sim->get_imsi(imsi);
-    MBED_ASSERT(err == NSAPI_ERROR_OK);
-    MBED_ASSERT(strlen(imsi) > 0);
+    TEST_ASSERT(err == NSAPI_ERROR_OK);
+    TEST_ASSERT(strlen(imsi) > 0);
 }
 
 using namespace utest::v1;

features/cellular/TESTS/socket/udp/main.cpp

@@ -145,7 +145,7 @@ static void network_callback(nsapi_event_t ev, intptr_t ptr)
 {
     if (ev == NSAPI_EVENT_CONNECTION_STATUS_CHANGE) {
         if (ptr == NSAPI_STATUS_GLOBAL_UP) {
-            MBED_ASSERT(network_semaphore.release() == osOK);
+            TEST_ASSERT(network_semaphore.release() == osOK);
         }
     }
 }

features/cellular/UNITTESTS/at/at_cellularinformation/at_cellularinformationtest.cpp

@@ -52,3 +52,7 @@ TEST(AT_CellularInformation, test_AT_CellularInformation_get_revision)
     unit->test_AT_CellularInformation_get_revision();
 }
 
+TEST(AT_CellularInformation, test_AT_CellularInformation_get_serial_number)
+{
+    unit->test_AT_CellularInformation_get_serial_number();
+}

features/cellular/UNITTESTS/at/at_cellularinformation/test_at_cellularinformation.cpp

@@ -20,6 +20,7 @@
 #include "ATHandler_stub.h"
 #include "EventQueue.h"
 #include "FileHandle_stub.h"
+#include "AT_CellularBase_stub.h"
 #include "ATHandler.h"
 #include "AT_CellularInformation.h"
 #include "AT_CellularBase.h"
@@ -43,10 +44,19 @@ void Test_AT_CellularInformation::test_AT_CellularInformation_get_manufacturer()
     ATHandler ah(&fh, eq, 0, ",");
     AT_CellularInformation aci(ah);
 
-    ATHandler_stub::nsapi_error_value = 8;
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
+    ATHandler_stub::read_string_value = "some";
+    ATHandler_stub::ssize_value = 4;
 
     char buf[8];
-    CHECK(8 == aci.get_manufacturer(buf, 8));
+    CHECK(NSAPI_ERROR_OK == aci.get_manufacturer(buf, 8));
+    CHECK(strcmp("some", buf) == 0);
+
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR;
+    ATHandler_stub::ssize_value = -1;
+    buf[0] = 0;
+    CHECK(NSAPI_ERROR_DEVICE_ERROR == aci.get_manufacturer(buf, 8));
+    CHECK(strlen(buf) == 0);
 }
 
 void Test_AT_CellularInformation::test_AT_CellularInformation_get_model()
@@ -56,10 +66,18 @@ void Test_AT_CellularInformation::test_AT_CellularInformation_get_model()
     ATHandler ah(&fh, eq, 0, ",");
     AT_CellularInformation aci(ah);
 
-    ATHandler_stub::nsapi_error_value = 7;
-
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
+    ATHandler_stub::read_string_value = "model";
+    ATHandler_stub::ssize_value = 5;
     char buf[8];
-    CHECK(7 == aci.get_model(buf, 8));
+    CHECK(NSAPI_ERROR_OK == aci.get_model(buf, 8));
+    CHECK(strcmp("model", buf) == 0);
+
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR;
+    ATHandler_stub::ssize_value = -1;
+    buf[0] = 0;
+    CHECK(NSAPI_ERROR_DEVICE_ERROR == aci.get_model(buf, 8));
+    CHECK(strlen(buf) == 0);
 }
 
 void Test_AT_CellularInformation::test_AT_CellularInformation_get_revision()
@@ -71,11 +89,53 @@ void Test_AT_CellularInformation::test_AT_CellularInformation_get_revision()
     //Used heap var here to visit heap constructor
     AT_CellularInformation *aci = new AT_CellularInformation(ah);
 
-    ATHandler_stub::nsapi_error_value = 6;
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
+    ATHandler_stub::read_string_value = "revision";
+    ATHandler_stub::ssize_value = 8;
 
-    char buf[8];
-    CHECK(6 == aci->get_revision(buf, 8));
+    char buf[9];
+    CHECK(NSAPI_ERROR_OK == aci->get_revision(buf, 9));
+    CHECK(strcmp("revision", buf) == 0);
+
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR;
+    ATHandler_stub::ssize_value = -1;
+    buf[0] = 0;
+    CHECK(NSAPI_ERROR_DEVICE_ERROR == aci->get_revision(buf, 8));
+    CHECK(strlen(buf) == 0);
 
     delete aci;
 }
 
+void Test_AT_CellularInformation::test_AT_CellularInformation_get_serial_number()
+{
+    EventQueue eq;
+    FileHandle_stub fh;
+    ATHandler ah(&fh, eq, 0, ",");
+    AT_CellularInformation aci(ah);
+
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
+    ATHandler_stub::read_string_value = "1234567";
+    ATHandler_stub::ssize_value = 7;
+    char buf[8];
+
+    CHECK(NSAPI_ERROR_OK == aci.get_serial_number(buf, 8, CellularInformation::SN));
+    CHECK(strcmp("1234567", buf) == 0);
+
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR;
+    ATHandler_stub::ssize_value = -1;
+    buf[0] = 0;
+    CHECK(NSAPI_ERROR_DEVICE_ERROR == aci.get_serial_number(buf, 8, CellularInformation::SN));
+    CHECK(strlen(buf) == 0);
+
+    AT_CellularBase_stub::supported_bool = false;
+    CHECK(NSAPI_ERROR_UNSUPPORTED == aci.get_serial_number(buf, 8, CellularInformation::IMEI));
+    CHECK(strlen(buf) == 0);
+
+    ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
+    ATHandler_stub::read_string_value = "1234567";
+    ATHandler_stub::ssize_value = 7;
+    AT_CellularBase_stub::supported_bool = true;
+    CHECK(NSAPI_ERROR_OK == aci.get_serial_number(buf, 8, CellularInformation::IMEI));
+    CHECK(strcmp("1234567", buf) == 0);
+}
+

features/cellular/UNITTESTS/at/at_cellularinformation/test_at_cellularinformation.h

@@ -29,6 +29,8 @@ class Test_AT_CellularInformation
     void test_AT_CellularInformation_get_model();
 
     void test_AT_CellularInformation_get_revision();
+
+    void test_AT_CellularInformation_get_serial_number();
 };
 
 #endif // TEST_AT_CELLULARINFORMATION_H

features/cellular/UNITTESTS/stubs/ATHandler_stub.cpp

@@ -164,7 +164,7 @@ ssize_t ATHandler::read_string(char *buf, size_t size, bool read_even_stop_tag)
 
     if (ATHandler_stub::read_string_index == kRead_string_table_size) {
         if (ATHandler_stub::read_string_value && ATHandler_stub::ssize_value >= 0) {
-            memcpy(buf, ATHandler_stub::read_string_value, ATHandler_stub::ssize_value);
+            memcpy(buf, ATHandler_stub::read_string_value, ATHandler_stub::ssize_value+1);
         }
         return ATHandler_stub::ssize_value;
     }

features/cellular/UNITTESTS/stubs/AT_CellularBase_stub.cpp

@@ -25,6 +25,7 @@ using namespace mbed;
 ATHandler *AT_CellularBase_stub::handler_value = NULL;
 ATHandler *AT_CellularBase_stub::handler_at_constructor_value = NULL;
 device_err_t AT_CellularBase_stub::device_err_value;
+bool AT_CellularBase_stub::supported_bool = true;
 
 AT_CellularBase::AT_CellularBase(ATHandler& at) : _at(at)
 {
@@ -43,5 +44,5 @@ device_err_t AT_CellularBase::get_device_error() const
 
 bool AT_CellularBase::is_supported(SupportedFeature feature)
 {
-    return true;
+    return AT_CellularBase_stub::supported_bool;
 }

features/cellular/UNITTESTS/stubs/AT_CellularBase_stub.h

@@ -21,4 +21,5 @@ namespace AT_CellularBase_stub {
     extern mbed::ATHandler *handler_value;
     extern mbed::ATHandler *handler_at_constructor_value;
     extern mbed::device_err_t device_err_value;
+    extern bool supported_bool;
 }