takashi kadono
/
Nucleo_446
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Embed:
(wiki syntax)
Show/hide line numbers
at_cellularnetworktest.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 <string.h> 00019 #include "AT_CellularNetwork.h" 00020 #include "EventQueue.h" 00021 #include "ATHandler.h" 00022 #include "AT_CellularDevice.h" 00023 #include "FileHandle_stub.h" 00024 #include "CellularLog.h" 00025 #include "ATHandler_stub.h" 00026 #include "AT_CellularStack.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_CellularNetwork : public testing::Test { 00034 protected: 00035 00036 void SetUp() 00037 { 00038 ATHandler_stub::int_count = kRead_int_table_size; 00039 ATHandler_stub::read_string_index = kRead_string_table_size; 00040 ATHandler_stub::resp_stop_success_count = kResp_stop_count_default; 00041 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00042 ATHandler_stub::int_value = -1; 00043 } 00044 00045 void TearDown() 00046 { 00047 } 00048 }; 00049 // *INDENT-ON* 00050 class my_stack : public AT_CellularStack { 00051 public: 00052 my_stack(ATHandler &atHandler) : AT_CellularStack(atHandler, 1, IPV4_STACK) {} 00053 virtual int get_max_socket_count() 00054 { 00055 return 1; 00056 } 00057 virtual int get_max_packet_size() 00058 { 00059 return 200; 00060 } 00061 virtual bool is_protocol_supported(nsapi_protocol_t protocol) 00062 { 00063 return true; 00064 } 00065 virtual nsapi_error_t socket_close_impl(int sock_id) 00066 { 00067 return NSAPI_ERROR_OK ; 00068 } 00069 virtual nsapi_error_t create_socket_impl(CellularSocket *socket) 00070 { 00071 return NSAPI_ERROR_OK ; 00072 } 00073 virtual nsapi_size_or_error_t socket_sendto_impl(CellularSocket *socket, const SocketAddress &address, 00074 const void *data, nsapi_size_t size) 00075 { 00076 return 100; 00077 } 00078 virtual nsapi_size_or_error_t socket_recvfrom_impl(CellularSocket *socket, SocketAddress *address, 00079 void *buffer, nsapi_size_t size) 00080 { 00081 return 100; 00082 } 00083 }; 00084 00085 class my_AT_CN : public AT_CellularNetwork { 00086 public: 00087 my_AT_CN(ATHandler &atHandler) : AT_CellularNetwork(atHandler) {} 00088 virtual ~my_AT_CN() {} 00089 NetworkStack *get_stack() 00090 { 00091 if (!_stack) { 00092 return new my_stack(get_at_handler()); 00093 } else { 00094 return _stack; 00095 } 00096 } 00097 virtual AT_CellularNetwork::RegistrationMode has_registration(RegistrationType reg_type) 00098 { 00099 if (reg_type == C_GREG) { 00100 return RegistrationModeDisable; 00101 } 00102 return RegistrationModeEnable; 00103 } 00104 virtual nsapi_error_t set_access_technology_impl(RadioAccessTechnology op_rat) 00105 { 00106 return NSAPI_ERROR_OK ; 00107 } 00108 virtual bool get_modem_stack_type(nsapi_ip_stack_t requested_stack) 00109 { 00110 if (requested_stack == IPV4_STACK || requested_stack == DEFAULT_STACK) { 00111 return true; 00112 } 00113 return false; 00114 } 00115 }; 00116 00117 class my_AT_CNipv6 : public AT_CellularNetwork { 00118 public: 00119 my_AT_CNipv6(ATHandler &atHandler) : AT_CellularNetwork(atHandler) {} 00120 virtual ~my_AT_CNipv6() {} 00121 NetworkStack *get_stack() 00122 { 00123 if (!_stack) { 00124 return new my_stack(get_at_handler()); 00125 } else { 00126 return _stack; 00127 } 00128 } 00129 virtual AT_CellularNetwork::RegistrationMode has_registration(RegistrationType reg_type) 00130 { 00131 if (reg_type == C_GREG) { 00132 return RegistrationModeDisable; 00133 } 00134 return RegistrationModeEnable; 00135 } 00136 virtual nsapi_error_t set_access_technology_impl(RadioAccessTechnology op_rat) 00137 { 00138 return NSAPI_ERROR_OK ; 00139 } 00140 virtual bool get_modem_stack_type(nsapi_ip_stack_t requested_stack) 00141 { 00142 if (requested_stack == IPV6_STACK || requested_stack == DEFAULT_STACK) { 00143 return true; 00144 } 00145 return false; 00146 } 00147 }; 00148 00149 static int network_cb_count; 00150 static void network_cb(nsapi_event_t ev, intptr_t intptr) 00151 { 00152 network_cb_count++; 00153 } 00154 00155 TEST_F(TestAT_CellularNetwork, Create) 00156 { 00157 EventQueue que; 00158 FileHandle_stub fh1; 00159 ATHandler at(&fh1, que, 0, ","); 00160 00161 AT_CellularNetwork *cn = new AT_CellularNetwork(at); 00162 EXPECT_TRUE(cn != NULL); 00163 delete cn; 00164 } 00165 00166 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_init) 00167 { 00168 EventQueue que; 00169 FileHandle_stub fh1; 00170 ATHandler at(&fh1, que, 0, ","); 00171 AT_CellularNetwork cn(at); 00172 00173 EXPECT_TRUE(NSAPI_ERROR_OK == cn.init()); 00174 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_NO_MEMORY ; 00175 EXPECT_TRUE(NSAPI_ERROR_NO_MEMORY == cn.init()); 00176 } 00177 00178 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_set_credentials) 00179 { 00180 EventQueue que; 00181 FileHandle_stub fh1; 00182 ATHandler at(&fh1, que, 0, ","); 00183 00184 AT_CellularNetwork *cnn = new AT_CellularNetwork(at); 00185 delete cnn; 00186 00187 AT_CellularNetwork cn(at); 00188 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn")); 00189 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", CellularNetwork::CHAP)); 00190 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", CellularNetwork::CHAP, NULL)); 00191 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", CellularNetwork::CHAP, NULL, NULL)); 00192 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", CellularNetwork::CHAP, NULL, "passwd")); 00193 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", CellularNetwork::CHAP, "user", NULL)); 00194 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", CellularNetwork::CHAP, "user")); 00195 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", CellularNetwork::CHAP, "user", "passwd")); 00196 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", NULL)); 00197 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", NULL, NULL)); 00198 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", NULL, "passwd")); 00199 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", "user", NULL)); 00200 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", "user")); 00201 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", "user", "passwd")); 00202 } 00203 00204 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_activate_context) 00205 { 00206 EventQueue que; 00207 FileHandle_stub fh1; 00208 ATHandler at(&fh1, que, 0, ","); 00209 00210 AT_CellularNetwork cn(at); 00211 my_AT_CN my_cn(at); 00212 my_AT_CNipv6 my_cnipv6(at); 00213 00214 // get_context return true and new context created. But now stack and so error. 00215 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00216 ATHandler_stub::bool_value = false; 00217 EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == cn.activate_context()); 00218 00219 // get_context return true and new context created, also do_user_authentication called with success. 00220 // But now stack and so error. 00221 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00222 ATHandler_stub::bool_value = false; 00223 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", CellularNetwork::CHAP, "user", "passwd")); 00224 EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == cn.activate_context()); 00225 00226 // get_context return true and new context created, also do_user_authentication called with failure. 00227 ATHandler_stub::resp_stop_success_count = 2; 00228 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00229 ATHandler_stub::bool_value = false; 00230 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_credentials("apn", CellularNetwork::CHAP, "user", "passwd")); 00231 EXPECT_TRUE(NSAPI_ERROR_AUTH_FAILURE == my_cn.activate_context()); 00232 00233 // get_context return true and new context created, also do_user_authentication called with success. 00234 // Now there is stack. 00235 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00236 ATHandler_stub::bool_value = false; 00237 ATHandler_stub::resp_stop_success_count = kResp_stop_count_default; 00238 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_credentials("apn", CellularNetwork::CHAP, "user", "passwd")); 00239 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.activate_context()); 00240 00241 // get_context return true and new context created, test delete context 00242 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00243 ATHandler_stub::bool_value = false; 00244 ATHandler_stub::resp_stop_success_count = kResp_stop_count_default; 00245 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_credentials("apn", CellularNetwork::CHAP, "user", "passwd")); 00246 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.activate_context()); 00247 00248 00249 00250 // get_context pdp type gives zero len, fails with no stack 00251 ATHandler_stub::resp_info_true_counter = 1; 00252 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00253 ATHandler_stub::bool_value = false; 00254 ATHandler_stub::read_string_index = 1; 00255 ATHandler_stub::read_string_table[0] = (char *)""; 00256 ATHandler_stub::int_value = 1; 00257 EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == cn.activate_context()); 00258 00259 // get_context pdp type gives proper type, apn reading fails 00260 ATHandler_stub::resp_info_true_counter = 1; 00261 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00262 ATHandler_stub::bool_value = false; 00263 ATHandler_stub::read_string_index = 1; 00264 ATHandler_stub::read_string_table[0] = (char *)"IPV6"; 00265 ATHandler_stub::int_value = 1; 00266 EXPECT_TRUE(NSAPI_ERROR_NO_CONNECTION == cn.activate_context()); 00267 00268 // get_context pdp type gives proper type, apn does not match, now other contexts so new one created 00269 ATHandler_stub::resp_info_true_counter = 1; 00270 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00271 ATHandler_stub::bool_value = false; 00272 ATHandler_stub::read_string_index = 2; 00273 ATHandler_stub::read_string_table[0] = (char *)"internet"; 00274 ATHandler_stub::read_string_table[1] = (char *)"IP"; 00275 ATHandler_stub::int_value = 1; 00276 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_credentials("apn", CellularNetwork::CHAP, "user", "passwd")); 00277 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.activate_context()); 00278 00279 // get_context pdp type gives proper type, apn match 00280 ATHandler_stub::resp_info_true_counter = 2; // set to 2 so cgact will give that this context is active 00281 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00282 ATHandler_stub::bool_value = false; 00283 ATHandler_stub::read_string_index = 2; 00284 ATHandler_stub::read_string_table[0] = (char *)"internet"; 00285 ATHandler_stub::read_string_table[1] = (char *)"IPV4V6"; 00286 ATHandler_stub::int_value = 1; 00287 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_stack_type(IPV4_STACK)); 00288 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_credentials("internet")); 00289 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.activate_context()); 00290 00291 // get_context pdp type gives proper type, apn match 00292 ATHandler_stub::resp_info_true_counter = 1; 00293 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00294 ATHandler_stub::bool_value = false; 00295 ATHandler_stub::read_string_index = 2; 00296 ATHandler_stub::read_string_table[0] = (char *)"internet"; 00297 ATHandler_stub::read_string_table[1] = (char *)"IPV6"; 00298 ATHandler_stub::int_value = 1; 00299 EXPECT_TRUE(NSAPI_ERROR_OK == my_cnipv6.set_stack_type(IPV6_STACK)); 00300 EXPECT_TRUE(NSAPI_ERROR_OK == my_cnipv6.set_credentials("internet")); 00301 EXPECT_TRUE(NSAPI_ERROR_OK == my_cnipv6.activate_context()); 00302 00303 // get_context pdp type gives proper type, apn match 00304 ATHandler_stub::resp_info_true_counter = 1; 00305 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00306 ATHandler_stub::bool_value = false; 00307 ATHandler_stub::read_string_index = 2; 00308 ATHandler_stub::read_string_table[0] = (char *)"internet"; 00309 ATHandler_stub::read_string_table[1] = (char *)"IPV4V6"; 00310 ATHandler_stub::int_value = 1; 00311 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_stack_type(DEFAULT_STACK)); 00312 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_credentials("internet")); 00313 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.activate_context()); 00314 00315 // get_context pdp type gives proper type, apn match 00316 ATHandler_stub::resp_info_true_counter = 1; 00317 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00318 ATHandler_stub::bool_value = false; 00319 ATHandler_stub::read_string_index = 2; 00320 ATHandler_stub::read_string_table[0] = (char *)"internet"; 00321 ATHandler_stub::read_string_table[1] = (char *)"IPV4V6"; 00322 ATHandler_stub::int_value = 1; 00323 EXPECT_TRUE(NSAPI_ERROR_OK == my_cnipv6.set_stack_type(DEFAULT_STACK)); 00324 EXPECT_TRUE(NSAPI_ERROR_OK == my_cnipv6.set_credentials("internet")); 00325 EXPECT_TRUE(NSAPI_ERROR_OK == my_cnipv6.activate_context()); 00326 00327 // get_context pdp type gives proper type, apn match 00328 ATHandler_stub::resp_info_true_counter = 1; 00329 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00330 ATHandler_stub::bool_value = false; 00331 ATHandler_stub::read_string_index = 2; 00332 ATHandler_stub::read_string_table[0] = (char *)"internet"; 00333 ATHandler_stub::read_string_table[1] = (char *)"IPV6"; 00334 ATHandler_stub::int_value = 1; 00335 EXPECT_TRUE(NSAPI_ERROR_OK == my_cnipv6.set_stack_type(DEFAULT_STACK)); 00336 EXPECT_TRUE(NSAPI_ERROR_OK == my_cnipv6.set_credentials("internet")); 00337 EXPECT_TRUE(NSAPI_ERROR_OK == my_cnipv6.activate_context()); 00338 00339 // get_context pdp type gives proper type, apn match 00340 ATHandler_stub::resp_info_true_counter = 1; 00341 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00342 ATHandler_stub::bool_value = false; 00343 ATHandler_stub::read_string_index = 2; 00344 ATHandler_stub::read_string_table[0] = (char *)"internet"; 00345 ATHandler_stub::read_string_table[1] = (char *)"IP"; 00346 ATHandler_stub::int_value = 1; 00347 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_stack_type(DEFAULT_STACK)); 00348 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_credentials("internet")); 00349 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.activate_context()); 00350 00351 // get_context pdp type gives proper type, apn match. Test Delete the created context. 00352 ATHandler_stub::resp_info_true_counter = 0; 00353 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00354 ATHandler_stub::bool_value = false; 00355 ATHandler_stub::int_value = 1; 00356 //ATHandler_stub::nsapi_error_ok_counter = 2; 00357 ATHandler_stub::resp_stop_success_count = 2; 00358 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_credentials(NULL, NULL, NULL)); 00359 EXPECT_TRUE(NSAPI_ERROR_NO_CONNECTION == my_cn.activate_context()); 00360 } 00361 00362 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_connect) 00363 { 00364 EventQueue que; 00365 FileHandle_stub fh1; 00366 ATHandler at(&fh1, que, 0, ","); 00367 00368 AT_CellularNetwork cn(at); 00369 00370 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00371 // no stack so will fail 00372 cn.attach(&network_cb); 00373 network_cb_count = 0; 00374 00375 EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == cn.connect("APN", "a", "b")); 00376 EXPECT_TRUE(NSAPI_STATUS_DISCONNECTED == cn.get_connection_status()); 00377 EXPECT_TRUE(network_cb_count == 2); 00378 00379 network_cb_count = 0; 00380 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 00381 EXPECT_TRUE(NSAPI_ERROR_NO_CONNECTION == cn.connect("APN")); 00382 EXPECT_TRUE(network_cb_count == 2); 00383 EXPECT_TRUE(NSAPI_STATUS_DISCONNECTED == cn.get_connection_status()); 00384 00385 my_AT_CN my_cn(at); 00386 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00387 ATHandler_stub::bool_value = false; 00388 cn.set_stack_type(IPV4_STACK); 00389 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.connect()); 00390 EXPECT_TRUE(network_cb_count == 2); 00391 EXPECT_TRUE(NSAPI_STATUS_GLOBAL_UP == my_cn.get_connection_status()); 00392 } 00393 00394 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_disconnect) 00395 { 00396 EventQueue que; 00397 FileHandle_stub fh1; 00398 ATHandler at(&fh1, que, 0, ","); 00399 00400 AT_CellularNetwork cn(at); 00401 EXPECT_TRUE(NSAPI_ERROR_OK == cn.disconnect()); 00402 } 00403 00404 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_stack) 00405 { 00406 EventQueue que; 00407 FileHandle_stub fh1; 00408 ATHandler at(&fh1, que, 0, ","); 00409 00410 my_AT_CN my_cn(at); 00411 my_stack *mystack = (my_stack *)my_cn.get_stack(); 00412 EXPECT_TRUE(mystack); 00413 delete mystack; 00414 } 00415 00416 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_set_registration) 00417 { 00418 EventQueue que; 00419 FileHandle_stub fh1; 00420 ATHandler at(&fh1, que, 0, ","); 00421 00422 AT_CellularNetwork cn(at); 00423 00424 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 00425 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_registration()); 00426 00427 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00428 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_registration()); 00429 00430 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 00431 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_registration("12345")); 00432 00433 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00434 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_registration("12345")); 00435 } 00436 00437 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_registration_status) 00438 { 00439 EventQueue que; 00440 FileHandle_stub fh1; 00441 ATHandler at(&fh1, que, 0, ","); 00442 00443 AT_CellularNetwork cn(at); 00444 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00445 ATHandler_stub::int_value = 3; 00446 CellularNetwork::RegistrationStatus stat = CellularNetwork::NotRegistered; 00447 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_registration_status(CellularNetwork::C_EREG, stat)); 00448 EXPECT_TRUE(stat == CellularNetwork::RegistrationDenied); 00449 stat = CellularNetwork::NotRegistered; 00450 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_registration_status(CellularNetwork::C_GREG, stat)); 00451 EXPECT_TRUE(stat == CellularNetwork::RegistrationDenied); 00452 00453 my_AT_CN nw(at); 00454 stat = CellularNetwork::NotRegistered; 00455 EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == nw.get_registration_status(CellularNetwork::C_GREG, stat)); 00456 EXPECT_TRUE(stat == CellularNetwork::NotRegistered); 00457 EXPECT_TRUE(NSAPI_ERROR_OK == nw.get_registration_status(CellularNetwork::C_EREG, stat)); 00458 EXPECT_TRUE(stat == CellularNetwork::RegistrationDenied); 00459 00460 00461 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 00462 stat = CellularNetwork::NotRegistered; 00463 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_registration_status(CellularNetwork::C_EREG, stat)); 00464 EXPECT_TRUE(stat == -1); 00465 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_registration_status(CellularNetwork::C_GREG, stat)); 00466 EXPECT_TRUE(stat == -1); 00467 00468 stat = CellularNetwork::NotRegistered; 00469 EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == nw.get_registration_status(CellularNetwork::C_GREG, stat)); 00470 EXPECT_TRUE(stat == CellularNetwork::NotRegistered); 00471 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == nw.get_registration_status(CellularNetwork::C_EREG, stat)); 00472 EXPECT_TRUE(stat == -1); 00473 } 00474 00475 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_network_registering_mode) 00476 { 00477 EventQueue que; 00478 FileHandle_stub fh1; 00479 ATHandler at(&fh1, que, 0, ","); 00480 00481 AT_CellularNetwork cn(at); 00482 00483 ATHandler_stub::int_value = 0; 00484 CellularNetwork::NWRegisteringMode mode = CellularNetwork::NWModeManual; 00485 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_network_registering_mode(mode)); 00486 EXPECT_TRUE(mode == CellularNetwork::NWModeAutomatic); 00487 00488 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 00489 mode = CellularNetwork::NWModeManual; 00490 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_network_registering_mode(mode)); 00491 EXPECT_TRUE(mode == -1); 00492 } 00493 00494 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_set_registration_urc) 00495 { 00496 EventQueue que; 00497 FileHandle_stub fh1; 00498 ATHandler at(&fh1, que, 0, ","); 00499 00500 AT_CellularNetwork cn(at); 00501 00502 CellularNetwork::RegistrationType type = CellularNetwork::C_EREG; 00503 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_registration_urc(type, true)); 00504 type = CellularNetwork::C_GREG; 00505 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_registration_urc(type, true)); 00506 type = CellularNetwork::C_REG; 00507 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_registration_urc(type, true)); 00508 00509 my_AT_CN nw(at); 00510 type = CellularNetwork::C_EREG; 00511 EXPECT_TRUE(NSAPI_ERROR_OK == nw.set_registration_urc(type, true)); 00512 type = CellularNetwork::C_GREG; 00513 EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == nw.set_registration_urc(type, true)); 00514 type = CellularNetwork::C_REG; 00515 EXPECT_TRUE(NSAPI_ERROR_OK == nw.set_registration_urc(type, true)); 00516 00517 type = CellularNetwork::C_EREG; 00518 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_registration_urc(type, false)); 00519 type = CellularNetwork::C_GREG; 00520 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_registration_urc(type, false)); 00521 type = CellularNetwork::C_REG; 00522 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_registration_urc(type, false)); 00523 00524 type = CellularNetwork::C_EREG; 00525 EXPECT_TRUE(NSAPI_ERROR_OK == nw.set_registration_urc(type, false)); 00526 type = CellularNetwork::C_GREG; 00527 EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == nw.set_registration_urc(type, false)); 00528 type = CellularNetwork::C_REG; 00529 EXPECT_TRUE(NSAPI_ERROR_OK == nw.set_registration_urc(type, false)); 00530 00531 00532 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 00533 type = CellularNetwork::C_EREG; 00534 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_registration_urc(type, true)); 00535 type = CellularNetwork::C_GREG; 00536 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_registration_urc(type, true)); 00537 type = CellularNetwork::C_REG; 00538 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_registration_urc(type, true)); 00539 00540 type = CellularNetwork::C_EREG; 00541 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == nw.set_registration_urc(type, true)); 00542 type = CellularNetwork::C_GREG; 00543 EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == nw.set_registration_urc(type, true)); 00544 type = CellularNetwork::C_REG; 00545 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == nw.set_registration_urc(type, true)); 00546 00547 type = CellularNetwork::C_EREG; 00548 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_registration_urc(type, false)); 00549 type = CellularNetwork::C_GREG; 00550 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_registration_urc(type, false)); 00551 type = CellularNetwork::C_REG; 00552 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_registration_urc(type, false)); 00553 00554 type = CellularNetwork::C_EREG; 00555 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == nw.set_registration_urc(type, false)); 00556 type = CellularNetwork::C_GREG; 00557 EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == nw.set_registration_urc(type, false)); 00558 type = CellularNetwork::C_REG; 00559 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == nw.set_registration_urc(type, false)); 00560 } 00561 00562 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_set_attach) 00563 { 00564 EventQueue que; 00565 FileHandle_stub fh1; 00566 ATHandler at(&fh1, que, 0, ","); 00567 00568 AT_CellularNetwork cn(at); 00569 ATHandler_stub::int_value = 0; 00570 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_attach()); 00571 ATHandler_stub::int_value = 1; 00572 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_attach()); 00573 00574 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 00575 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_attach()); 00576 } 00577 00578 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_attach) 00579 { 00580 EventQueue que; 00581 FileHandle_stub fh1; 00582 ATHandler at(&fh1, que, 0, ","); 00583 00584 AT_CellularNetwork cn(at); 00585 CellularNetwork::AttachStatus stat = CellularNetwork::Detached; 00586 ATHandler_stub::int_value = 1; 00587 ATHandler_stub::bool_value = true; 00588 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_attach(stat)); 00589 EXPECT_TRUE(stat == CellularNetwork::Attached); 00590 00591 ATHandler_stub::int_value = 0; 00592 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_attach(stat)); 00593 EXPECT_TRUE(stat == CellularNetwork::Detached); 00594 00595 stat = CellularNetwork::Attached; 00596 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 00597 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_attach(stat)); 00598 EXPECT_TRUE(stat == CellularNetwork::Detached); 00599 00600 00601 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00602 ATHandler_stub::bool_value = false; 00603 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_attach(stat)); 00604 EXPECT_TRUE(stat == CellularNetwork::Detached); 00605 00606 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 00607 ATHandler_stub::bool_value = false; 00608 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_attach(stat)); 00609 EXPECT_TRUE(stat == CellularNetwork::Detached); 00610 } 00611 00612 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_detach) 00613 { 00614 EventQueue que; 00615 FileHandle_stub fh1; 00616 ATHandler at(&fh1, que, 0, ","); 00617 00618 my_AT_CN cn(at); 00619 00620 EXPECT_TRUE(NSAPI_ERROR_OK == cn.detach()); 00621 00622 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 00623 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.detach()); 00624 00625 // connect so we can test callback in detach 00626 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00627 ATHandler_stub::bool_value = false; 00628 cn.set_stack_type(IPV4_STACK); 00629 EXPECT_TRUE(NSAPI_ERROR_OK == cn.connect()); 00630 EXPECT_TRUE(NSAPI_STATUS_GLOBAL_UP == cn.get_connection_status()); 00631 // attach callback 00632 cn.attach(&network_cb); 00633 network_cb_count = 0; 00634 EXPECT_TRUE(NSAPI_ERROR_OK == cn.detach()); 00635 EXPECT_TRUE(network_cb_count == 1); 00636 EXPECT_TRUE(NSAPI_STATUS_DISCONNECTED == cn.get_connection_status()); 00637 } 00638 00639 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_rate_control) 00640 { 00641 EventQueue que; 00642 FileHandle_stub fh1; 00643 ATHandler at(&fh1, que, 0, ","); 00644 00645 AT_CellularNetwork cn(at); 00646 int ur = -1; 00647 CellularNetwork::RateControlExceptionReports reports = CellularNetwork::NotAllowedToBeSent; 00648 CellularNetwork::RateControlUplinkTimeUnit timeUnit = CellularNetwork::Unrestricted; 00649 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 00650 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_rate_control(reports, timeUnit, ur)); 00651 EXPECT_TRUE(reports == CellularNetwork::NotAllowedToBeSent); 00652 EXPECT_TRUE(timeUnit == CellularNetwork::Unrestricted); 00653 EXPECT_TRUE(ur == -1); 00654 00655 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00656 ATHandler_stub::int_value = 1; 00657 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_rate_control(reports, timeUnit, ur)); 00658 EXPECT_TRUE(reports == CellularNetwork::AllowedToBeSent); 00659 EXPECT_TRUE(timeUnit == CellularNetwork::Minute); 00660 EXPECT_TRUE(ur == 1); 00661 00662 // test second if in get_rate_control 00663 reports = CellularNetwork::NotAllowedToBeSent; 00664 timeUnit = CellularNetwork::Unrestricted; 00665 ur = -1; 00666 00667 ATHandler_stub::int_count = 1; 00668 ATHandler_stub::int_valid_count_table[0] = 1; 00669 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00670 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_rate_control(reports, timeUnit, ur)); 00671 EXPECT_TRUE(reports == CellularNetwork::NotAllowedToBeSent); 00672 EXPECT_TRUE(timeUnit == CellularNetwork::Unrestricted); 00673 EXPECT_TRUE(ur == -1); 00674 00675 // test second if in get_rate_control 00676 ATHandler_stub::int_count = 2; 00677 ATHandler_stub::int_valid_count_table[0] = 1; 00678 ATHandler_stub::int_valid_count_table[1] = 1; 00679 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00680 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_rate_control(reports, timeUnit, ur)); 00681 EXPECT_TRUE(reports == CellularNetwork::AllowedToBeSent); 00682 EXPECT_TRUE(timeUnit == CellularNetwork::Unrestricted); 00683 EXPECT_TRUE(ur == -1); 00684 00685 // test third if in get_rate_control 00686 ATHandler_stub::int_count = 3; 00687 ATHandler_stub::int_valid_count_table[0] = 3; 00688 ATHandler_stub::int_valid_count_table[1] = 1; 00689 ATHandler_stub::int_valid_count_table[2] = 1; 00690 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00691 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_rate_control(reports, timeUnit, ur)); 00692 EXPECT_TRUE(reports == CellularNetwork::AllowedToBeSent); 00693 EXPECT_TRUE(timeUnit == CellularNetwork::Day); 00694 EXPECT_TRUE(ur == -1); 00695 00696 ATHandler_stub::int_count = 4; 00697 ATHandler_stub::int_valid_count_table[0] = 5; 00698 ATHandler_stub::int_valid_count_table[1] = 3; 00699 ATHandler_stub::int_valid_count_table[2] = 1; 00700 ATHandler_stub::int_valid_count_table[3] = 1; 00701 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00702 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_rate_control(reports, timeUnit, ur)); 00703 EXPECT_TRUE(reports == CellularNetwork::AllowedToBeSent); 00704 EXPECT_TRUE(timeUnit == CellularNetwork::Day); 00705 EXPECT_TRUE(ur == 5); 00706 } 00707 00708 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_apn_backoff_timer) 00709 { 00710 EventQueue que; 00711 FileHandle_stub fh1; 00712 ATHandler at(&fh1, que, 0, ","); 00713 00714 AT_CellularNetwork cn(at); 00715 int time = -1; 00716 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 00717 EXPECT_TRUE(NSAPI_ERROR_PARAMETER == cn.get_apn_backoff_timer(time)); 00718 EXPECT_TRUE(time == -1); 00719 00720 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00721 EXPECT_TRUE(NSAPI_ERROR_PARAMETER == cn.get_apn_backoff_timer(time)); 00722 EXPECT_TRUE(time == -1); 00723 00724 ATHandler_stub::resp_info_true_counter = 0; 00725 ATHandler_stub::bool_value = false; 00726 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00727 cn.set_credentials("internet", NULL, NULL); 00728 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_apn_backoff_timer(time)); 00729 EXPECT_TRUE(time == -1); 00730 00731 ATHandler_stub::resp_info_true_counter = 0; 00732 ATHandler_stub::bool_value = true; 00733 ATHandler_stub::int_value = 55; 00734 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00735 cn.set_credentials("internet", NULL, NULL); 00736 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_apn_backoff_timer(time)); 00737 EXPECT_TRUE(time == 55); 00738 } 00739 00740 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_ip_address) 00741 { 00742 EventQueue que; 00743 FileHandle_stub fh1; 00744 ATHandler at(&fh1, que, 0, ","); 00745 00746 AT_CellularNetwork cn(at); 00747 EXPECT_TRUE(!cn.get_ip_address()); 00748 } 00749 00750 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_set_access_technology) 00751 { 00752 EventQueue que; 00753 FileHandle_stub fh1; 00754 ATHandler at(&fh1, que, 0, ","); 00755 00756 AT_CellularNetwork cn(at); 00757 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00758 EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == cn.set_access_technology(CellularNetwork::RAT_UNKNOWN)); 00759 EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == cn.set_access_technology(CellularNetwork::RAT_GSM_COMPACT)); 00760 00761 my_AT_CN my_cn(at); 00762 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_access_technology(CellularNetwork::RAT_GSM_COMPACT)); 00763 } 00764 00765 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_access_technology) 00766 { 00767 EventQueue que; 00768 FileHandle_stub fh1; 00769 ATHandler at(&fh1, que, 0, ","); 00770 00771 AT_CellularNetwork cn(at); 00772 CellularNetwork::RadioAccessTechnology rat; 00773 00774 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_access_technology(rat)); 00775 EXPECT_TRUE(CellularNetwork::RAT_UNKNOWN == rat); 00776 } 00777 00778 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_scan_plmn) 00779 { 00780 EventQueue que; 00781 FileHandle_stub fh1; 00782 ATHandler at(&fh1, que, 0, ","); 00783 00784 AT_CellularNetwork cn(at); 00785 int c = -1; 00786 CellularNetwork::operList_t ops; 00787 ATHandler_stub::bool_value = false; 00788 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 00789 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.scan_plmn(ops, c)); 00790 EXPECT_TRUE(c == 0); 00791 00792 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00793 EXPECT_TRUE(NSAPI_ERROR_OK == cn.scan_plmn(ops, c)); 00794 EXPECT_TRUE(c == 0); 00795 00796 00797 ATHandler_stub::read_string_index = 3; 00798 ATHandler_stub::read_string_table[0] = (char *)"44444"; 00799 ATHandler_stub::read_string_table[1] = (char *)"33333"; 00800 ATHandler_stub::read_string_table[2] = (char *)"12345"; 00801 ATHandler_stub::int_value = 1; 00802 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00803 ATHandler_stub::info_elem_true_counter = 1; 00804 ATHandler_stub::bool_value = false; 00805 EXPECT_TRUE(NSAPI_ERROR_OK == cn.scan_plmn(ops, c)); 00806 EXPECT_TRUE(c == 1); 00807 EXPECT_TRUE(ops.get_head() != NULL); 00808 CellularNetwork::operator_t *op = ops.get_head(); 00809 EXPECT_TRUE(op->op_status == CellularNetwork::operator_t::Available); 00810 EXPECT_TRUE(strcmp(op->op_long, "12345") == 0); 00811 EXPECT_TRUE(strcmp(op->op_short, "33333") == 0); 00812 EXPECT_TRUE(strcmp(op->op_num, "44444") == 0); 00813 ops.delete_all(); 00814 00815 ATHandler_stub::read_string_index = 3; 00816 ATHandler_stub::int_value = 6; // RAT_HSDPA_HSUPA 00817 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00818 ATHandler_stub::info_elem_true_counter = 1; 00819 ATHandler_stub::bool_value = false; 00820 EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == cn.set_access_technology(CellularNetwork::RAT_UTRAN)); 00821 EXPECT_TRUE(NSAPI_ERROR_OK == cn.scan_plmn(ops, c)); 00822 EXPECT_TRUE(c == 0); 00823 EXPECT_TRUE(ops.get_head() == NULL); 00824 } 00825 00826 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_set_ciot_optimization_config) 00827 { 00828 EventQueue que; 00829 FileHandle_stub fh1; 00830 ATHandler at(&fh1, que, 0, ","); 00831 00832 AT_CellularNetwork cn(at); 00833 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00834 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_ciot_optimization_config(CellularNetwork::SUPPORTED_UE_OPT_NO_SUPPORT, CellularNetwork::PREFERRED_UE_OPT_NO_PREFERENCE)); 00835 00836 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 00837 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_ciot_optimization_config(CellularNetwork::SUPPORTED_UE_OPT_NO_SUPPORT, CellularNetwork::PREFERRED_UE_OPT_NO_PREFERENCE)); 00838 } 00839 00840 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_ciot_optimization_config) 00841 { 00842 EventQueue que; 00843 FileHandle_stub fh1; 00844 ATHandler at(&fh1, que, 0, ","); 00845 00846 AT_CellularNetwork cn(at); 00847 CellularNetwork::Supported_UE_Opt sup = CellularNetwork::SUPPORTED_UE_OPT_NO_SUPPORT; 00848 CellularNetwork::Preferred_UE_Opt pref = CellularNetwork::PREFERRED_UE_OPT_NO_PREFERENCE; 00849 ATHandler_stub::int_value = 1; 00850 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00851 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_ciot_optimization_config(sup, pref)); 00852 EXPECT_TRUE(sup == CellularNetwork::SUPPORTED_UE_OPT_CONTROL_PLANE); 00853 EXPECT_TRUE(pref == CellularNetwork::PREFERRED_UE_OPT_CONTROL_PLANE); 00854 00855 sup = CellularNetwork::SUPPORTED_UE_OPT_NO_SUPPORT; 00856 pref = CellularNetwork::PREFERRED_UE_OPT_NO_PREFERENCE; 00857 ATHandler_stub::int_value = 1; 00858 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 00859 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_ciot_optimization_config(sup, pref)); 00860 EXPECT_TRUE(sup == CellularNetwork::SUPPORTED_UE_OPT_NO_SUPPORT); 00861 EXPECT_TRUE(pref == CellularNetwork::PREFERRED_UE_OPT_NO_PREFERENCE); 00862 } 00863 00864 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_set_stack_type) 00865 { 00866 EventQueue que; 00867 FileHandle_stub fh1; 00868 ATHandler at(&fh1, que, 0, ","); 00869 00870 AT_CellularNetwork cn(at); 00871 EXPECT_TRUE(NSAPI_ERROR_PARAMETER == cn.set_stack_type(IPV4_STACK)); 00872 00873 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_stack_type(DEFAULT_STACK)); 00874 } 00875 00876 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_stack_type) 00877 { 00878 EventQueue que; 00879 FileHandle_stub fh1; 00880 ATHandler at(&fh1, que, 0, ","); 00881 00882 AT_CellularNetwork cn(at); 00883 EXPECT_TRUE(DEFAULT_STACK == cn.get_stack_type()); 00884 00885 my_AT_CN my_cn(at); 00886 EXPECT_TRUE(DEFAULT_STACK == my_cn.get_stack_type()); 00887 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_stack_type(IPV4_STACK)); 00888 EXPECT_TRUE(DEFAULT_STACK == my_cn.get_stack_type()); 00889 } 00890 00891 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_pdpcontext_params) 00892 { 00893 EventQueue que; 00894 FileHandle_stub fh1; 00895 ATHandler at(&fh1, que, 0, ","); 00896 00897 AT_CellularNetwork cn(at); 00898 CellularNetwork::pdpContextList_t list; 00899 00900 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 00901 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_pdpcontext_params(list)); 00902 00903 // don't got to while loop 00904 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00905 ATHandler_stub::bool_value = false; 00906 ATHandler_stub::resp_info_true_counter = 0; 00907 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_pdpcontext_params(list)); 00908 EXPECT_TRUE(NULL == list.get_head()); 00909 00910 // go to while loop and check values 00911 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00912 ATHandler_stub::resp_info_true_counter = 1; 00913 ATHandler_stub::int_count = 9; 00914 ATHandler_stub::int_valid_count_table[8] = 1; 00915 ATHandler_stub::int_valid_count_table[7] = 2; 00916 ATHandler_stub::int_valid_count_table[6] = 3; 00917 ATHandler_stub::int_valid_count_table[5] = 4; 00918 ATHandler_stub::int_valid_count_table[4] = 5; 00919 ATHandler_stub::int_valid_count_table[3] = 6; 00920 ATHandler_stub::int_valid_count_table[2] = 7; 00921 ATHandler_stub::int_valid_count_table[1] = 8; 00922 ATHandler_stub::int_valid_count_table[0] = 9; 00923 00924 ATHandler_stub::read_string_index = 7; 00925 ATHandler_stub::read_string_table[6] = (char *)"internet"; 00926 ATHandler_stub::read_string_table[5] = (char *)"1.2.3.4.5.6.7.8.9.10.11.112.13.14.15.16.1.2.3.44.55.6.7.8.9.10.11.12.13.14.15.16"; 00927 ATHandler_stub::read_string_table[4] = (char *)"23.33.44.1.2.3.55.123.225.34.11.1.0.0.123.234"; 00928 ATHandler_stub::read_string_table[3] = (char *)"1.2.3.4"; 00929 ATHandler_stub::read_string_table[2] = (char *)"0.255.0.255"; 00930 ATHandler_stub::read_string_table[1] = (char *)"25.66.77.88"; 00931 ATHandler_stub::read_string_table[0] = (char *)"004.003.002.001"; 00932 00933 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_pdpcontext_params(list)); 00934 CellularNetwork::pdpcontext_params_t *params = list.get_head(); 00935 EXPECT_TRUE(params != NULL); 00936 EXPECT_TRUE(params->next == NULL); 00937 EXPECT_TRUE(params->cid == 1); 00938 EXPECT_TRUE(params->bearer_id == 2); 00939 EXPECT_TRUE(params->im_signalling_flag == 3); 00940 EXPECT_TRUE(params->lipa_indication == 4); 00941 EXPECT_TRUE(params->ipv4_mtu == 5); 00942 EXPECT_TRUE(params->wlan_offload == 6); 00943 EXPECT_TRUE(params->local_addr_ind == 7); 00944 EXPECT_TRUE(params->non_ip_mtu == 8); 00945 EXPECT_TRUE(params->serving_plmn_rate_control_value == 9); 00946 EXPECT_TRUE(strcmp(params->apn, "internet") == 0); 00947 EXPECT_TRUE(strcmp(params->local_addr, "102:304:506:708:90A:B70:D0E:F10") == 0); 00948 EXPECT_TRUE(strcmp(params->local_subnet_mask, "102:32C:3706:708:90A:B0C:D0E:F10") == 0); 00949 EXPECT_TRUE(strcmp(params->gateway_addr, "1721:2C01:203:377B:E122:B01:000:7BEA") == 0); 00950 EXPECT_TRUE(strcmp(params->dns_primary_addr, "1.2.3.4") == 0); 00951 EXPECT_TRUE(strcmp(params->dns_secondary_addr, "0.255.0.255") == 0); 00952 EXPECT_TRUE(strcmp(params->p_cscf_prim_addr, "25.66.77.88") == 0); 00953 EXPECT_TRUE(strcmp(params->p_cscf_sec_addr, "004.003.002.001") == 0); 00954 } 00955 00956 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_extended_signal_quality) 00957 { 00958 EventQueue que; 00959 FileHandle_stub fh1; 00960 ATHandler at(&fh1, que, 0, ","); 00961 00962 AT_CellularNetwork cn(at); 00963 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 00964 int rx = -1, be = -1, rs = -1, ec = -1, rsrq = -1, rsrp = -1; 00965 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_extended_signal_quality(rx, be, rs, ec, rsrq, rsrp)); 00966 EXPECT_TRUE(rx == -1 && be == -1 && rs == -1 && ec == -1 && rsrq == -1 && rsrp == -1); 00967 00968 ATHandler_stub::int_value = 5; 00969 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00970 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_extended_signal_quality(rx, be, rs, ec, rsrq, rsrp)); 00971 EXPECT_TRUE(rx == 5 && be == 5 && rs == 5 && ec == 5 && rsrq == 5 && rsrp == 5); 00972 } 00973 00974 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_signal_quality) 00975 { 00976 EventQueue que; 00977 FileHandle_stub fh1; 00978 ATHandler at(&fh1, que, 0, ","); 00979 00980 AT_CellularNetwork cn(at); 00981 int rs = -1, ber = -1; 00982 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 00983 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_signal_quality(rs, ber)); 00984 EXPECT_TRUE(rs == -1 && ber == -1); 00985 00986 ATHandler_stub::int_value = 1; 00987 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 00988 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_signal_quality(rs, ber)); 00989 EXPECT_TRUE(rs == 1 && ber == 1); 00990 } 00991 00992 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_cell_id) 00993 { 00994 EventQueue que; 00995 FileHandle_stub fh1; 00996 ATHandler at(&fh1, que, 0, ","); 00997 00998 AT_CellularNetwork cn(at); 00999 int id = 0; 01000 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_cell_id(id)); 01001 EXPECT_TRUE(id == -1); 01002 01003 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 01004 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_cell_id(id)); 01005 EXPECT_TRUE(id == -1); 01006 01007 ATHandler_stub::read_string_index = 2; 01008 ATHandler_stub::read_string_table[1] = (char *)"00C3"; 01009 ATHandler_stub::read_string_table[0] = (char *)"1234FFC1"; //== cellid and in dec: 305463233 01010 ATHandler_stub::int_value = 1; 01011 // Get registration status to modify cell_id 01012 CellularNetwork::RegistrationType type; 01013 CellularNetwork::RegistrationStatus status; 01014 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 01015 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_registration_status(CellularNetwork::C_EREG, status)); 01016 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_cell_id(id)); 01017 EXPECT_TRUE(id == 305463233); 01018 } 01019 01020 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_3gpp_error) 01021 { 01022 EventQueue que; 01023 FileHandle_stub fh1; 01024 ATHandler at(&fh1, que, 0, ","); 01025 01026 AT_CellularNetwork cn(at); 01027 ATHandler_stub::int_value = 8; 01028 EXPECT_TRUE(8 == cn.get_3gpp_error()); 01029 } 01030 01031 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_operator_params) 01032 { 01033 EventQueue que; 01034 FileHandle_stub fh1; 01035 ATHandler at(&fh1, que, 0, ","); 01036 01037 AT_CellularNetwork cn(at); 01038 int format; 01039 CellularNetwork::operator_t ops; 01040 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 01041 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_operator_params(format, ops)); 01042 01043 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 01044 ATHandler_stub::int_value = 0; 01045 ATHandler_stub::read_string_index = 1; 01046 ATHandler_stub::read_string_table[0] = (char *)"12345"; 01047 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_operator_params(format, ops)); 01048 EXPECT_TRUE(format == 0); 01049 EXPECT_TRUE(strcmp(ops.op_long, "12345") == 0); 01050 EXPECT_TRUE(strlen(ops.op_short) == 0); 01051 EXPECT_TRUE(strlen(ops.op_num) == 0); 01052 EXPECT_TRUE(ops.op_rat == CellularNetwork::RAT_GSM); 01053 01054 ops.op_long[0] = 0; 01055 ATHandler_stub::int_value = 1; 01056 ATHandler_stub::read_string_index = 1; 01057 ATHandler_stub::read_string_table[0] = (char *)"12345"; 01058 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_operator_params(format, ops)); 01059 EXPECT_TRUE(format == 1); 01060 EXPECT_TRUE(strlen(ops.op_long) == 0); 01061 EXPECT_TRUE(strcmp(ops.op_short, "12345") == 0); 01062 EXPECT_TRUE(strlen(ops.op_num) == 0); 01063 EXPECT_TRUE(ops.op_rat == CellularNetwork::RAT_GSM_COMPACT); 01064 01065 ops.op_short[0] = 0; 01066 ATHandler_stub::int_value = 2; 01067 ATHandler_stub::read_string_index = 1; 01068 ATHandler_stub::read_string_table[0] = (char *)"12345"; 01069 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_operator_params(format, ops)); 01070 EXPECT_TRUE(format == 2); 01071 EXPECT_TRUE(strlen(ops.op_long) == 0); 01072 EXPECT_TRUE(strlen(ops.op_short) == 0); 01073 EXPECT_TRUE(strcmp(ops.op_num, "12345") == 0); 01074 EXPECT_TRUE(ops.op_rat == CellularNetwork::RAT_UTRAN); 01075 } 01076 01077 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_operator_names) 01078 { 01079 EventQueue que; 01080 FileHandle_stub fh1; 01081 ATHandler at(&fh1, que, 0, ","); 01082 01083 AT_CellularNetwork cn(at); 01084 CellularNetwork::operator_names_list name_list; 01085 01086 ATHandler_stub::resp_info_true_counter = 0; 01087 ATHandler_stub::bool_value = false; 01088 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_operator_names(name_list)); 01089 EXPECT_TRUE(name_list.get_head() == NULL); 01090 01091 ATHandler_stub::resp_info_true_counter = 1; 01092 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 01093 EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_operator_names(name_list)); 01094 EXPECT_TRUE(name_list.get_head() != NULL); 01095 EXPECT_TRUE(name_list.get_head()->next == NULL); 01096 01097 ATHandler_stub::resp_info_true_counter = 1; 01098 ATHandler_stub::bool_value = false; 01099 ATHandler_stub::read_string_index = 2; 01100 ATHandler_stub::read_string_table[1] = (char *)"12345"; 01101 ATHandler_stub::read_string_table[0] = (char *)"56789"; 01102 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 01103 name_list.delete_all(); 01104 EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_operator_names(name_list)); 01105 CellularNetwork::operator_names_t *op_names = name_list.get_head(); 01106 EXPECT_TRUE(op_names != NULL); 01107 EXPECT_TRUE(op_names->next == NULL); 01108 EXPECT_TRUE(strcmp(op_names->numeric, "12345") == 0); 01109 EXPECT_TRUE(strcmp(op_names->alpha, "56789") == 0); 01110 } 01111 01112 TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_attach) 01113 { 01114 EventQueue que; 01115 FileHandle_stub fh1; 01116 ATHandler at(&fh1, que, 0, ","); 01117 01118 AT_CellularNetwork cn(at); 01119 01120 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 01121 network_cb_count = 0; 01122 cn.attach(&network_cb); 01123 EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == cn.connect()); 01124 EXPECT_TRUE(network_cb_count == 2); // check that attached callback was called twice 01125 } 01126 01127 TEST_F(TestAT_CellularNetwork, test_get_connection_status) 01128 { 01129 EventQueue que; 01130 FileHandle_stub fh1; 01131 ATHandler at(&fh1, que, 0, ","); 01132 01133 AT_CellularNetwork cn(at); 01134 01135 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 01136 network_cb_count = 0; 01137 cn.attach(&network_cb); 01138 EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == cn.connect()); 01139 EXPECT_TRUE(network_cb_count == 2); // check that attached callback was called twice 01140 EXPECT_TRUE(NSAPI_STATUS_DISCONNECTED == cn.get_connection_status()); 01141 01142 my_AT_CN my_cn(at); 01143 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 01144 ATHandler_stub::bool_value = false; 01145 cn.set_stack_type(IPV4_STACK); 01146 EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.connect()); 01147 EXPECT_TRUE(network_cb_count == 2); 01148 EXPECT_TRUE(NSAPI_STATUS_GLOBAL_UP == my_cn.get_connection_status()); 01149 } 01150 01151 TEST_F(TestAT_CellularNetwork, test_set_blocking) 01152 { 01153 EventQueue que; 01154 FileHandle_stub fh1; 01155 ATHandler at(&fh1, que, 0, ","); 01156 01157 AT_CellularNetwork cn(at); 01158 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ; 01159 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_blocking(false)); 01160 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_blocking(true)); 01161 01162 ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ; 01163 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_blocking(false)); 01164 EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_blocking(true)); 01165 } 01166
Generated on Tue Aug 9 2022 00:37:03 by
1.7.2