test_at_cellularnetwork.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 "CppUTest/TestHarness.h"
00018 #include "test_at_cellularnetwork.h"
00019 #include <string.h>
00020 #include "AT_CellularNetwork.h"
00021 #include "EventQueue.h"
00022 #include "ATHandler.h"
00023 #include "AT_CellularDevice.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 class my_AT_CN : public AT_CellularNetwork {
00032 public:
00033     my_AT_CN(ATHandler &atHandler) : AT_CellularNetwork(atHandler) {}
00034     virtual ~my_AT_CN() {}
00035     NetworkStack *get_stack() {return AT_CellularNetwork::get_stack();}
00036 };
00037 
00038 void conn_stat_cb(nsapi_error_t error)
00039 {
00040 
00041 }
00042 
00043 Test_AT_CellularNetwork::Test_AT_CellularNetwork()
00044 {
00045     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00046     ATHandler_stub::int_value = -1;
00047 }
00048 
00049 Test_AT_CellularNetwork::~Test_AT_CellularNetwork()
00050 {
00051 }
00052 
00053 void Test_AT_CellularNetwork::test_AT_CellularNetwork_constructor()
00054 {
00055     EventQueue que;
00056     FileHandle_stub fh1;
00057     ATHandler at(&fh1, que, 0, ",");
00058 
00059     AT_CellularNetwork *cn = new AT_CellularNetwork(at);
00060 
00061     delete cn;
00062 }
00063 
00064 void Test_AT_CellularNetwork::test_AT_CellularNetwork_set_credentials()
00065 {
00066     EventQueue que;
00067     FileHandle_stub fh1;
00068     ATHandler at(&fh1, que, 0, ",");
00069 
00070     AT_CellularNetwork cn(at);
00071     CHECK(NSAPI_ERROR_OK  == cn.set_credentials("apn", CellularNetwork::CHAP));
00072 
00073     CHECK(NSAPI_ERROR_OK  == cn.set_credentials("apn"));
00074 }
00075 
00076 void Test_AT_CellularNetwork::test_AT_CellularNetwork_connect()
00077 {
00078     EventQueue que;
00079     FileHandle_stub fh1;
00080     ATHandler at(&fh1, que, 0, ",");
00081 
00082     AT_CellularNetwork cn(at);
00083     cn.set_stack_type(IPV4V6_STACK);
00084     CHECK(NSAPI_ERROR_NO_CONNECTION  == cn.connect("APN", "a", "b"));
00085 
00086     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_CONNECTION_LOST ;
00087     CHECK(NSAPI_ERROR_NO_CONNECTION  == cn.connect("APN"));
00088 }
00089 
00090 void Test_AT_CellularNetwork::test_AT_CellularNetwork_disconnect()
00091 {
00092     EventQueue que;
00093     FileHandle_stub fh1;
00094     ATHandler at(&fh1, que, 0, ",");
00095 
00096     AT_CellularNetwork cn(at);
00097     CHECK(NSAPI_ERROR_OK  == cn.disconnect());
00098 }
00099 
00100 void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_stack()
00101 {
00102     EventQueue que;
00103     FileHandle_stub fh1;
00104     ATHandler at(&fh1, que, 0, ",");
00105 
00106     my_AT_CN cn(at);
00107     CHECK(!cn.get_stack());
00108 }
00109 
00110 void Test_AT_CellularNetwork::test_AT_CellularNetwork_set_registration()
00111 {
00112     EventQueue que;
00113     FileHandle_stub fh1;
00114     ATHandler at(&fh1, que, 0, ",");
00115 
00116     AT_CellularNetwork cn(at);
00117     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_CONNECTION_LOST ;
00118     CHECK(NSAPI_ERROR_CONNECTION_LOST  == cn.set_registration());
00119 }
00120 
00121 void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_registration_status()
00122 {
00123     EventQueue que;
00124     FileHandle_stub fh1;
00125     ATHandler at(&fh1, que, 0, ",");
00126 
00127     AT_CellularNetwork cn(at);
00128     CellularNetwork::RegistrationStatus stat;
00129     CHECK(NSAPI_ERROR_OK  == cn.get_registration_status(CellularNetwork::C_EREG, stat));
00130 }
00131 
00132 void Test_AT_CellularNetwork::test_AT_CellularNetwork_set_attach()
00133 {
00134     EventQueue que;
00135     FileHandle_stub fh1;
00136     ATHandler at(&fh1, que, 0, ",");
00137 
00138     AT_CellularNetwork cn(at);
00139     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_CONNECTION_LOST ;
00140     CHECK(NSAPI_ERROR_CONNECTION_LOST  == cn.set_attach());
00141 }
00142 
00143 void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_attach()
00144 {
00145     EventQueue que;
00146     FileHandle_stub fh1;
00147     ATHandler at(&fh1, que, 0, ",");
00148 
00149     AT_CellularNetwork cn(at);
00150     CellularNetwork::AttachStatus stat;
00151     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_CONNECTION_LOST ;
00152     CHECK(NSAPI_ERROR_CONNECTION_LOST  == cn.get_attach(stat));
00153 }
00154 
00155 void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_rate_control()
00156 {
00157     EventQueue que;
00158     FileHandle_stub fh1;
00159     ATHandler at(&fh1, que, 0, ",");
00160 
00161     AT_CellularNetwork cn(at);
00162     int ur;
00163     CellularNetwork::RateControlExceptionReports reports;
00164     CellularNetwork::RateControlUplinkTimeUnit timeUnit;
00165     CHECK(NSAPI_ERROR_OK  == cn.get_rate_control(reports, timeUnit, ur));
00166 }
00167 
00168 void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_apn_backoff_timer()
00169 {
00170     EventQueue que;
00171     FileHandle_stub fh1;
00172     ATHandler at(&fh1, que, 0, ",");
00173 
00174     AT_CellularNetwork cn(at);
00175     int time;
00176     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_CONNECTION_LOST ;
00177     CHECK(NSAPI_ERROR_CONNECTION_LOST  == cn.get_apn_backoff_timer(time));
00178 }
00179 
00180 
00181 void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_ip_address()
00182 {
00183     EventQueue que;
00184     FileHandle_stub fh1;
00185     ATHandler at(&fh1, que, 0, ",");
00186 
00187     AT_CellularNetwork cn(at);
00188     CHECK(!cn.get_ip_address());
00189 }
00190 
00191 void Test_AT_CellularNetwork::test_AT_CellularNetwork_set_access_technology()
00192 {
00193     EventQueue que;
00194     FileHandle_stub fh1;
00195     ATHandler at(&fh1, que, 0, ",");
00196 
00197     AT_CellularNetwork cn(at);
00198     CHECK(NSAPI_ERROR_UNSUPPORTED  == cn.set_access_technology(CellularNetwork::operator_t::RAT_UNKNOWN));
00199     CHECK(NSAPI_ERROR_UNSUPPORTED  == cn.set_access_technology(CellularNetwork::operator_t::RAT_GSM_COMPACT));
00200 }
00201 
00202 void Test_AT_CellularNetwork::test_AT_CellularNetwork_scan_plmn()
00203 {
00204     EventQueue que;
00205     FileHandle_stub fh1;
00206     ATHandler at(&fh1, que, 0, ",");
00207 
00208     AT_CellularNetwork cn(at);
00209     int c;
00210     CellularNetwork::operList_t ops;
00211     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_CONNECTION_LOST ;
00212     CHECK(NSAPI_ERROR_CONNECTION_LOST  == cn.scan_plmn(ops, c));
00213 }
00214 
00215 void Test_AT_CellularNetwork::test_AT_CellularNetwork_set_ciot_optimization_config()
00216 {
00217     EventQueue que;
00218     FileHandle_stub fh1;
00219     ATHandler at(&fh1, que, 0, ",");
00220 
00221     AT_CellularNetwork cn(at);
00222     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_CONNECTION_LOST ;
00223     CHECK(NSAPI_ERROR_CONNECTION_LOST  == cn.set_ciot_optimization_config(CellularNetwork::SUPPORTED_UE_OPT_NO_SUPPORT, CellularNetwork::PREFERRED_UE_OPT_NO_PREFERENCE));
00224 }
00225 
00226 void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_ciot_optimization_config()
00227 {
00228     EventQueue que;
00229     FileHandle_stub fh1;
00230     ATHandler at(&fh1, que, 0, ",");
00231 
00232     AT_CellularNetwork cn(at);
00233     CellularNetwork::Supported_UE_Opt sup;
00234     CellularNetwork::Preferred_UE_Opt pref;
00235     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_CONNECTION_LOST ;
00236     CHECK(NSAPI_ERROR_CONNECTION_LOST  == cn.get_ciot_optimization_config(sup, pref));
00237 }
00238 
00239 void Test_AT_CellularNetwork::test_AT_CellularNetwork_set_stack_type()
00240 {
00241     EventQueue que;
00242     FileHandle_stub fh1;
00243     ATHandler at(&fh1, que, 0, ",");
00244 
00245     AT_CellularNetwork cn(at);
00246     CHECK(NSAPI_ERROR_PARAMETER  == cn.set_stack_type(IPV4_STACK));
00247 
00248     CHECK(NSAPI_ERROR_OK  == cn.set_stack_type(DEFAULT_STACK));
00249 }
00250 
00251 void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_stack_type()
00252 {
00253     EventQueue que;
00254     FileHandle_stub fh1;
00255     ATHandler at(&fh1, que, 0, ",");
00256 
00257     AT_CellularNetwork cn(at);
00258     CHECK(DEFAULT_STACK == cn.get_stack_type());
00259 }
00260 
00261 void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_pdpcontext_params()
00262 {
00263     EventQueue que;
00264     FileHandle_stub fh1;
00265     ATHandler at(&fh1, que, 0, ",");
00266 
00267     AT_CellularNetwork cn(at);
00268     CellularNetwork::pdpContextList_t list;
00269     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_CONNECTION_LOST ;
00270     CHECK(NSAPI_ERROR_CONNECTION_LOST  == cn.get_pdpcontext_params(list));
00271 }
00272 
00273 void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_extended_signal_quality()
00274 {
00275     EventQueue que;
00276     FileHandle_stub fh1;
00277     ATHandler at(&fh1, que, 0, ",");
00278 
00279     AT_CellularNetwork cn(at);
00280     int rx,be,rs,ec,rsrq,rsrp;
00281     CHECK(NSAPI_ERROR_DEVICE_ERROR  == cn.get_extended_signal_quality(rx, be,rs,ec,rsrq, rsrp));
00282 
00283     ATHandler_stub::int_value = 1;
00284     CHECK(NSAPI_ERROR_OK  == cn.get_extended_signal_quality(rx, be,rs,ec,rsrq, rsrp));
00285 }
00286 
00287 void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_signal_quality()
00288 {
00289     EventQueue que;
00290     FileHandle_stub fh1;
00291     ATHandler at(&fh1, que, 0, ",");
00292 
00293     AT_CellularNetwork cn(at);
00294     int rs,ber;
00295     CHECK(NSAPI_ERROR_DEVICE_ERROR  == cn.get_signal_quality(rs,ber));
00296 
00297     ATHandler_stub::int_value = 1;
00298     CHECK(NSAPI_ERROR_OK  == cn.get_signal_quality(rs,ber));
00299 }
00300 
00301 void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_cell_id()
00302 {
00303     EventQueue que;
00304     FileHandle_stub fh1;
00305     ATHandler at(&fh1, que, 0, ",");
00306 
00307     AT_CellularNetwork cn(at);
00308     int id;
00309     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_CONNECTION_LOST ;
00310     CHECK(NSAPI_ERROR_CONNECTION_LOST  == cn.get_cell_id(id));
00311 }
00312 
00313 void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_3gpp_error()
00314 {
00315     EventQueue que;
00316     FileHandle_stub fh1;
00317     ATHandler at(&fh1, que, 0, ",");
00318 
00319     AT_CellularNetwork cn(at);
00320     ATHandler_stub::int_value = 8;
00321     CHECK(8 == cn.get_3gpp_error());
00322 }
00323 
00324 void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_operator_params()
00325 {
00326     EventQueue que;
00327     FileHandle_stub fh1;
00328     ATHandler at(&fh1, que, 0, ",");
00329 
00330     AT_CellularNetwork cn(at);
00331     int format;
00332     CellularNetwork::operator_t ops;
00333     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_CONNECTION_LOST ;
00334     CHECK(NSAPI_ERROR_CONNECTION_LOST  == cn.get_operator_params(format, ops));
00335 }
00336