at_cellularsimtest.cpp

00001 /*
00002  * Copyright (c) 2018, Arm Limited and affiliates.
00003  * SPDX-License-Identifier: Apache-2.0
00004  *
00005  * Licensed under the Apache License, Version 2.0 (the "License");
00006  * you may not use this file except in compliance with the License.
00007  * You may obtain a copy of the License at
00008  *
00009  *     http://www.apache.org/licenses/LICENSE-2.0
00010  *
00011  * Unless required by applicable law or agreed to in writing, software
00012  * distributed under the License is distributed on an "AS IS" BASIS,
00013  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00014  * See the License for the specific language governing permissions and
00015  * limitations under the License.
00016  */
00017 #include "gtest/gtest.h"
00018 #include "ATHandler_stub.h"
00019 #include <string.h>
00020 #include "AT_CellularNetwork.h"
00021 #include "EventQueue.h"
00022 #include "ATHandler.h"
00023 #include "AT_CellularSIM.h"
00024 #include "FileHandle_stub.h"
00025 #include "CellularLog.h"
00026 #include "ATHandler_stub.h"
00027 
00028 using namespace mbed;
00029 using namespace events;
00030 
00031 // AStyle ignored as the definition is not clear due to preprocessor usage
00032 // *INDENT-OFF*
00033 class TestAT_CellularSIM : public testing::Test {
00034 protected:
00035 
00036     void SetUp()
00037     {
00038         ATHandler_stub::read_string_index = kRead_string_table_size;
00039         ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00040         ATHandler_stub::read_string_value = NULL;
00041         ATHandler_stub::ssize_value = 0;
00042     }
00043 
00044     void TearDown()
00045     {
00046     }
00047 };
00048 // *INDENT-ON*
00049 
00050 TEST_F(TestAT_CellularSIM, Create)
00051 {
00052     EventQueue que;
00053     FileHandle_stub fh1;
00054     ATHandler at(&fh1, que, 0, ",");
00055 
00056     AT_CellularSIM *sim = new AT_CellularSIM(at);
00057 
00058     EXPECT_TRUE(sim != NULL);
00059     delete sim;
00060 }
00061 
00062 TEST_F(TestAT_CellularSIM, test_AT_CellularSIM_set_pin)
00063 {
00064     EventQueue que;
00065     FileHandle_stub fh1;
00066     ATHandler at(&fh1, que, 0, ",");
00067 
00068     AT_CellularSIM sim(at);
00069     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00070     EXPECT_TRUE(NSAPI_ERROR_OK  == sim.set_pin("12"));
00071 
00072     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ;
00073     EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR  == sim.set_pin("12"));
00074 
00075     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00076     ATHandler_stub::read_string_value = (char *)"READY";
00077     ATHandler_stub::ssize_value = 5;
00078     EXPECT_TRUE(NSAPI_ERROR_OK  == sim.set_pin("12"));
00079 
00080     EXPECT_TRUE(NSAPI_ERROR_OK  == sim.set_pin(NULL));
00081 }
00082 
00083 TEST_F(TestAT_CellularSIM, test_AT_CellularSIM_change_pin)
00084 {
00085     EventQueue que;
00086     FileHandle_stub fh1;
00087     ATHandler at(&fh1, que, 0, ",");
00088 
00089     AT_CellularSIM sim(at);
00090     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00091     EXPECT_TRUE(NSAPI_ERROR_OK  == sim.change_pin("12", "34"));
00092     EXPECT_TRUE(NSAPI_ERROR_OK  == sim.change_pin(NULL, "34"));
00093     EXPECT_TRUE(NSAPI_ERROR_OK  == sim.change_pin("12", NULL));
00094     EXPECT_TRUE(NSAPI_ERROR_OK  == sim.change_pin(NULL, NULL));
00095 
00096     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ;
00097     EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR  == sim.change_pin("12", "34"));
00098 }
00099 
00100 TEST_F(TestAT_CellularSIM, test_AT_CellularSIM_set_pin_query)
00101 {
00102     EventQueue que;
00103     FileHandle_stub fh1;
00104     ATHandler at(&fh1, que, 0, ",");
00105 
00106     AT_CellularSIM sim(at);
00107     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00108     EXPECT_TRUE(NSAPI_ERROR_OK  == sim.set_pin_query("12", true));
00109     EXPECT_TRUE(NSAPI_ERROR_OK  == sim.set_pin_query(NULL, true));
00110 
00111     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00112     EXPECT_TRUE(NSAPI_ERROR_OK  == sim.set_pin_query("12", false));
00113     EXPECT_TRUE(NSAPI_ERROR_OK  == sim.set_pin_query(NULL, false));
00114 
00115     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ;
00116     EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR  == sim.set_pin_query("12", false));
00117     EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR  == sim.set_pin_query("12", true));
00118 }
00119 
00120 TEST_F(TestAT_CellularSIM, test_AT_CellularSIM_get_sim_state)
00121 {
00122     EventQueue que;
00123     FileHandle_stub fh1;
00124     ATHandler at(&fh1, que, 0, ",");
00125 
00126     AT_CellularSIM sim(at);
00127     CellularSIM::SimState state;
00128     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00129     ATHandler_stub::ssize_value = -1;
00130     ATHandler_stub::read_string_value = NULL;
00131     EXPECT_TRUE(NSAPI_ERROR_OK  == sim.get_sim_state(state));
00132     EXPECT_TRUE(CellularSIM::SimStateUnknown == state);
00133 
00134     ATHandler_stub::read_string_value = (char *)"READY";
00135     ATHandler_stub::ssize_value = 5;
00136     EXPECT_TRUE(NSAPI_ERROR_OK  == sim.get_sim_state(state));
00137     EXPECT_TRUE(CellularSIM::SimStateReady == state);
00138 
00139     ATHandler_stub::read_string_value = (char *)"SIM PIN";
00140     ATHandler_stub::ssize_value = 7;
00141     EXPECT_TRUE(NSAPI_ERROR_OK  == sim.get_sim_state(state));
00142     EXPECT_TRUE(CellularSIM::SimStatePinNeeded == state);
00143 
00144     ATHandler_stub::read_string_value = (char *)"SIM PUK";
00145     ATHandler_stub::ssize_value = 7;
00146     EXPECT_TRUE(NSAPI_ERROR_OK  == sim.get_sim_state(state));
00147     EXPECT_TRUE(CellularSIM::SimStatePukNeeded == state);
00148 
00149     ATHandler_stub::read_string_value = (char *)"SOME CRAP";
00150     ATHandler_stub::ssize_value = 9;
00151     EXPECT_TRUE(NSAPI_ERROR_OK  == sim.get_sim_state(state));
00152     EXPECT_TRUE(CellularSIM::SimStateUnknown == state);
00153 }
00154 
00155 TEST_F(TestAT_CellularSIM, test_AT_CellularSIM_get_imsi)
00156 {
00157     EventQueue que;
00158     FileHandle_stub fh1;
00159     ATHandler at(&fh1, que, 0, ",");
00160 
00161     char imsi[16];
00162     AT_CellularSIM sim(at);
00163     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00164     ATHandler_stub::read_string_value = (char *)"123456789012345";
00165     ATHandler_stub::ssize_value = 15;
00166     EXPECT_TRUE(NSAPI_ERROR_OK  == sim.get_imsi(imsi));
00167     EXPECT_TRUE(strcmp(ATHandler_stub::read_string_value, imsi) == 0);
00168 
00169     ATHandler_stub::read_string_value = NULL;
00170     ATHandler_stub::ssize_value = -1;
00171     ATHandler_stub::read_string_index = -1;
00172     imsi[0] = 0;
00173     EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR  == sim.get_imsi(imsi));
00174     EXPECT_TRUE(strlen(imsi) == 0);
00175 
00176     EXPECT_TRUE(NSAPI_ERROR_PARAMETER  == sim.get_imsi(NULL));
00177 
00178     // this would fail as get_imsi should take another param which is the size of the buffer which we could use for validation.
00179     // Now we have improved documentation that that the given imsi buffer size must be over 15.
00180     //char imsi2[5];
00181     //EXPECT_TRUE(NSAPI_ERROR_PARAMETER == sim.get_imsi(imsi2));
00182 }
00183 
00184 TEST_F(TestAT_CellularSIM, test_AT_CellularSIM_get_iccid)
00185 {
00186     EventQueue que;
00187     FileHandle_stub fh1;
00188     ATHandler at(&fh1, que, 0, ",");
00189 
00190     char buf[16];
00191     AT_CellularSIM sim(at);
00192     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00193     ATHandler_stub::read_string_value = (char *)"123456789012345";
00194     ATHandler_stub::ssize_value = 15;
00195     EXPECT_TRUE(NSAPI_ERROR_OK  == sim.get_iccid(buf, 16));
00196     EXPECT_TRUE(strcmp(ATHandler_stub::read_string_value, buf) == 0);
00197 
00198     buf[0] = 0;
00199     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ;
00200     ATHandler_stub::read_string_value = NULL;
00201     ATHandler_stub::ssize_value = -1;
00202     EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR  == sim.get_iccid(buf, 16));
00203     EXPECT_TRUE(strlen(buf) == 0);
00204 }