test_athandler.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_athandler.h"
00019 #include <string.h>
00020 #include "AT_CellularNetwork.h"
00021 #include "EventQueue.h"
00022 #include "ATHandler.h"
00023 #include "AT_CellularStack.h"
00024 #include "FileHandle_stub.h"
00025 #include "CellularLog.h"
00026 #include "mbed_poll_stub.h"
00027 
00028 #include "Timer_stub.h"
00029 
00030 using namespace mbed;
00031 using namespace events;
00032 
00033 void urc_callback()
00034 {
00035 }
00036 
00037 Test_ATHandler::Test_ATHandler()
00038 {
00039 
00040 }
00041 
00042 Test_ATHandler::~Test_ATHandler()
00043 {
00044 }
00045 
00046 void Test_ATHandler::test_ATHandler_constructor()
00047 {
00048     EventQueue que;
00049     FileHandle_stub fh1;
00050 
00051     ATHandler *at = new ATHandler(&fh1, que, 0, ",");
00052 
00053     delete at;
00054 
00055     at = new ATHandler(&fh1, que, 0, NULL);
00056 
00057     delete at;
00058 }
00059 
00060 void Test_ATHandler::test_ATHandler_get_file_handle()
00061 {
00062     EventQueue que;
00063     FileHandle_stub fh1;
00064 
00065     ATHandler at(&fh1, que, 0, ",");
00066     CHECK_EQUAL(&fh1, at.get_file_handle());
00067 }
00068 
00069 void Test_ATHandler::test_ATHandler_set_file_handle()
00070 {
00071     EventQueue que;
00072     FileHandle_stub fh1, fh2;
00073 
00074     ATHandler at(&fh1, que, 0, ",");
00075 
00076     at.set_file_handle(&fh2);
00077 }
00078 
00079 void Test_ATHandler::test_ATHandler_lock()
00080 {
00081     EventQueue que;
00082     FileHandle_stub fh1;
00083 
00084     ATHandler at(&fh1, que, 0, ",");
00085 
00086     at.lock();
00087 }
00088 
00089 void Test_ATHandler::test_ATHandler_unlock()
00090 {
00091     EventQueue que;
00092     FileHandle_stub fh1;
00093 
00094     ATHandler at(&fh1, que, 0, ",");
00095     filehandle_stub_short_value_counter = 1;
00096     fh1.short_value = POLLIN;
00097     at.unlock();
00098 }
00099 
00100 void Test_ATHandler::test_ATHandler_unlock_return_error()
00101 {
00102     EventQueue que;
00103     FileHandle_stub fh1;
00104 
00105     ATHandler at(&fh1, que, 0, ",");
00106     CHECK(NSAPI_ERROR_OK  == at.unlock_return_error());
00107 }
00108 
00109 void Test_ATHandler::test_ATHandler_set_urc_handler()
00110 {
00111     EventQueue que;
00112     FileHandle_stub fh1;
00113 
00114     ATHandler at(&fh1, que, 0, ",");
00115     const char ch[] = "testtesttesttest";
00116     at.set_urc_handler(ch, &urc_callback);
00117 }
00118 
00119 void Test_ATHandler::test_ATHandler_get_last_error()
00120 {
00121     EventQueue que;
00122     FileHandle_stub fh1;
00123 
00124     ATHandler at(&fh1, que, 0, ",");
00125     CHECK(NSAPI_ERROR_OK  == at.get_last_error());
00126 }
00127 
00128 void Test_ATHandler::test_ATHandler_get_last_device_error()
00129 {
00130     EventQueue que;
00131     FileHandle_stub fh1;
00132 
00133     ATHandler at(&fh1, que, 0, ",");
00134     CHECK(0 == at.get_last_device_error().errCode);
00135 }
00136 
00137 void Test_ATHandler::test_ATHandler_inc_ref_count()
00138 {
00139     EventQueue que;
00140     FileHandle_stub fh1;
00141 
00142     ATHandler at(&fh1, que, 0, ",");
00143     at.inc_ref_count();
00144 }
00145 
00146 void Test_ATHandler::test_ATHandler_dec_ref_count()
00147 {
00148     EventQueue que;
00149     FileHandle_stub fh1;
00150 
00151     ATHandler at(&fh1, que, 0, ",");
00152     at.dec_ref_count();
00153 }
00154 
00155 void Test_ATHandler::test_ATHandler_get_ref_count()
00156 {
00157     EventQueue que;
00158     FileHandle_stub fh1;
00159 
00160     ATHandler at(&fh1, que, 0, ",");
00161     CHECK(1 == at.get_ref_count());
00162 
00163     at.inc_ref_count();
00164     CHECK(2 == at.get_ref_count());
00165 
00166     at.inc_ref_count();
00167     CHECK(3 == at.get_ref_count());
00168 
00169     at.dec_ref_count();
00170     at.dec_ref_count();
00171     CHECK(1 == at.get_ref_count());
00172 }
00173 
00174 void Test_ATHandler::test_ATHandler_set_at_timeout()
00175 {
00176     EventQueue que;
00177     FileHandle_stub fh1;
00178 
00179     ATHandler at(&fh1, que, 0, ",");
00180     at.set_at_timeout(8);
00181 
00182     at.set_at_timeout(80, true);
00183 }
00184 
00185 void Test_ATHandler::test_ATHandler_restore_at_timeout()
00186 {
00187     EventQueue que;
00188     FileHandle_stub fh1;
00189 
00190     ATHandler at(&fh1, que, 0, ",");
00191     at.set_at_timeout(80, true);
00192     at.set_at_timeout(800);
00193     at.restore_at_timeout();
00194 }
00195 
00196 void Test_ATHandler::test_ATHandler_clear_error()
00197 {
00198     EventQueue que;
00199     FileHandle_stub fh1;
00200 
00201     ATHandler at(&fh1, que, 0, ",");
00202     at.clear_error();
00203 }
00204 
00205 void Test_ATHandler::test_ATHandler_process_oob()
00206 {
00207     EventQueue que;
00208     FileHandle_stub fh1;
00209 
00210     ATHandler at(&fh1, que, 0, ",");
00211     filehandle_stub_short_value_counter = 1;
00212     fh1.short_value = POLLIN;
00213     at.set_urc_handler("s", &urc_callback);
00214     at.process_oob();
00215 
00216     filehandle_stub_short_value_counter = 2;
00217     at.process_oob();
00218 
00219     //at.fill_buffer();
00220     uint8_t buf[5];
00221     at.clear_error();
00222     char table[] = "ssssssssssssssssssssssssssssssss\0";
00223     filehandle_stub_table = table;
00224     filehandle_stub_table_pos = 0;
00225     at.read_bytes(buf, 5);
00226 
00227     filehandle_stub_short_value_counter = 2;
00228     at.process_oob();
00229 
00230     at.clear_error();
00231     timer_stub_value = 0;
00232     filehandle_stub_table_pos = 0;
00233     at.read_bytes(buf, 5);
00234 
00235     filehandle_stub_short_value_counter = 1;
00236     at.process_oob();
00237 
00238     char table2[4];
00239     table2[0] = '\r';
00240     table2[1] = '\r';
00241     table2[2] = '\n';
00242     table2[3] = 0;
00243     filehandle_stub_table = table2;
00244 
00245     at.clear_error();
00246     timer_stub_value = 0;
00247     filehandle_stub_table_pos = 0;
00248     at.read_bytes(buf, 1);
00249 
00250     filehandle_stub_short_value_counter = 1;
00251     at.process_oob();
00252 
00253 
00254     filehandle_stub_table = table;
00255 
00256 
00257     filehandle_stub_short_value_counter = 0;
00258     filehandle_stub_table_pos = 0;
00259     filehandle_stub_table = NULL;
00260 }
00261 
00262 void Test_ATHandler::test_ATHandler_set_filehandle_sigio()
00263 {
00264     EventQueue que;
00265     FileHandle_stub fh1;
00266 
00267     ATHandler at(&fh1, que, 0, ",");
00268     at.set_filehandle_sigio();
00269 }
00270 
00271 void Test_ATHandler::test_ATHandler_flush()
00272 {
00273     EventQueue que;
00274     FileHandle_stub fh1;
00275 
00276     ATHandler at(&fh1, que, 0, ",");
00277     filehandle_stub_short_value_counter = 1;
00278     fh1.short_value = POLLIN;
00279     at.flush();
00280 }
00281 
00282 void Test_ATHandler::test_ATHandler_cmd_start()
00283 {
00284     EventQueue que;
00285     FileHandle_stub fh1;
00286 
00287     ATHandler at(&fh1, que, 0, ",");
00288     mbed_poll_stub::revents_value = POLLOUT;
00289     mbed_poll_stub::int_value = 1;
00290     fh1.size_value = 3;
00291     at.cmd_start("s");
00292     mbed_poll_stub::revents_value = POLLIN;
00293     mbed_poll_stub::int_value = 0;
00294 
00295     at.cmd_start("s");
00296 
00297     at.cmd_start("s");
00298 }
00299 
00300 void Test_ATHandler::test_ATHandler_write_int()
00301 {
00302     EventQueue que;
00303     FileHandle_stub fh1;
00304 
00305     ATHandler at(&fh1, que, 0, ",");
00306     fh1.size_value = -1;
00307     at.write_int(4);
00308 
00309     at.clear_error();
00310     mbed_poll_stub::revents_value = POLLOUT;
00311     mbed_poll_stub::int_value = 1;
00312     fh1.size_value = 6;
00313     at.write_int(4);
00314 
00315     at.write_int(2147483647);
00316 
00317     at.write_int(2147483647+1);
00318 
00319 //    at.at_error(0, DeviceErrorType(0));
00320 //    at.write_int(4);
00321 }
00322 
00323 void Test_ATHandler::test_ATHandler_write_string()
00324 {
00325     EventQueue que;
00326     FileHandle_stub fh1;
00327 
00328     ATHandler at(&fh1, que, 0, ",");
00329     at.write_string("help");
00330     CHECK(NSAPI_ERROR_DEVICE_ERROR  == at.get_last_error());
00331 
00332     at.clear_error();
00333     mbed_poll_stub::revents_value = POLLOUT;
00334     mbed_poll_stub::int_value = 1;
00335     fh1.size_value = -1;
00336     at.cmd_start("s");
00337     at.write_string("help", true);
00338     CHECK(NSAPI_ERROR_DEVICE_ERROR  == at.get_last_error());
00339 
00340     at.clear_error();
00341     mbed_poll_stub::revents_value = POLLOUT;
00342     mbed_poll_stub::int_value = 1;
00343     fh1.size_value = -1;
00344     at.write_string("help", true);
00345     CHECK(NSAPI_ERROR_DEVICE_ERROR  == at.get_last_error());
00346 
00347     at.clear_error();
00348     mbed_poll_stub::revents_value = POLLOUT;
00349     mbed_poll_stub::int_value = 1;
00350     fh1.size_value = 7;
00351     at.write_string("help", true);
00352     CHECK(NSAPI_ERROR_OK  == at.get_last_error());
00353 }
00354 
00355 void Test_ATHandler::test_ATHandler_cmd_stop()
00356 {
00357     EventQueue que;
00358     FileHandle_stub fh1;
00359 
00360     ATHandler at(&fh1, que, 0, ",");
00361     fh1.size_value = -1;
00362     at.cmd_stop();
00363 
00364     at.write_string("help", true);
00365 
00366     at.cmd_stop();
00367     CHECK(NSAPI_ERROR_DEVICE_ERROR  == at.get_last_error());
00368 }
00369 
00370 void Test_ATHandler::test_ATHandler_write_bytes()
00371 {
00372     EventQueue que;
00373     FileHandle_stub fh1;
00374 
00375     ATHandler at(&fh1, que, 0, ",");
00376     fh1.size_value = -1;
00377     uint8_t data[] = "data";
00378     at.write_bytes(data, 4);
00379 
00380     at.write_bytes(data, 4);
00381     CHECK(NSAPI_ERROR_DEVICE_ERROR  == at.get_last_error());
00382 }
00383 
00384 void Test_ATHandler::test_ATHandler_set_stop_tag()
00385 {
00386     EventQueue que;
00387     FileHandle_stub fh1;
00388 
00389     ATHandler at(&fh1, que, 0, ",");
00390     at.set_stop_tag("s");
00391 }
00392 
00393 void Test_ATHandler::test_ATHandler_set_delimiter()
00394 {
00395     EventQueue que;
00396     FileHandle_stub fh1;
00397 
00398     ATHandler at(&fh1, que, 0, ",");
00399     at.set_delimiter('+');
00400 }
00401 
00402 void Test_ATHandler::test_ATHandler_skip_param()
00403 {
00404     EventQueue que;
00405     FileHandle_stub fh1;
00406 
00407     ATHandler at(&fh1, que, 0, ",");
00408     at.skip_param();
00409 
00410     char table[] = "ssssssssssssssssssssssssssssOK\r\n\0";
00411     filehandle_stub_table = table;
00412     filehandle_stub_table_pos = 0;
00413 
00414     at.flush();
00415     at.clear_error();
00416     at.resp_start();
00417     at.skip_param();
00418     CHECK(at.get_last_error() == NSAPI_ERROR_DEVICE_ERROR );
00419 
00420     char table1[] = "ss,sssssssssssss,sssssssssssOK\r\n\0";
00421     filehandle_stub_table = table1;
00422     filehandle_stub_table_pos = 0;
00423 
00424     at.flush();
00425     at.clear_error();
00426     at.resp_start();
00427     at.skip_param();
00428 
00429     char table2[] = "sssOK\r\n\0";
00430     filehandle_stub_table = table2;
00431     filehandle_stub_table_pos = 0;
00432 
00433     at.flush();
00434     at.clear_error();
00435     at.resp_start();
00436     at.skip_param();
00437 
00438     char table3[] = "sssssssOK\nssss\0";
00439     filehandle_stub_table = table3;
00440     filehandle_stub_table_pos = 0;
00441 
00442     //Need to create a new instance because stop tag already found
00443     ATHandler at2(&fh1, que, 0, ",");
00444     at2.flush();
00445     at2.clear_error();
00446     at2.resp_start();
00447     at2.skip_param();
00448 
00449     at2.skip_param(4, 3);
00450 
00451     filehandle_stub_table = table3;
00452     filehandle_stub_table_pos = 0;
00453 
00454     at2.flush();
00455     at2.clear_error();
00456     at2.resp_start();
00457     at2.skip_param(4, 3);
00458 
00459     filehandle_stub_table = table3;
00460     filehandle_stub_table_pos = 0;
00461 
00462     at2.flush();
00463     at2.clear_error();
00464     at2.resp_start();
00465     at2.skip_param(24, 17);
00466 }
00467 
00468 void Test_ATHandler::test_ATHandler_read_bytes()
00469 {
00470     EventQueue que;
00471     FileHandle_stub fh1;
00472 
00473     ATHandler at(&fh1, que, 0, ",");
00474     uint8_t buf[5];
00475     CHECK(-1 == at.read_bytes(buf, 25));
00476 
00477     CHECK(-1 == at.read_bytes(buf, 5));
00478 
00479     char table[] = "ssssssssssssssssssssssssssssOK\r\n\0";
00480     filehandle_stub_table = table;
00481     filehandle_stub_table_pos = 0;
00482 
00483     at.clear_error();
00484     CHECK(5 == at.read_bytes(buf, 5));
00485 }
00486 
00487 void Test_ATHandler::test_ATHandler_read_string()
00488 {
00489     EventQueue que;
00490     FileHandle_stub fh1;
00491 
00492     ATHandler at(&fh1, que, 0, ",");
00493 
00494     char table[] = "\"s,\"OK\r\n\0";
00495     filehandle_stub_table = table;
00496     filehandle_stub_table_pos = 0;
00497 
00498     char buf[5];
00499     uint8_t buf2[5];
00500     at.flush();
00501     at.clear_error();
00502     at.resp_start();
00503     at.read_bytes(buf2, 5);
00504     CHECK(-1 == at.read_string(buf, 15));
00505 
00506     filehandle_stub_table = table;
00507     filehandle_stub_table_pos = 0;
00508 
00509     at.flush();
00510     at.clear_error();
00511     at.resp_start();
00512     at.read_bytes(buf2, 1);
00513     CHECK(1 == at.read_string(buf, 5, true));
00514 
00515     char table2[] = "\"s\"OK\r\n\0";
00516     filehandle_stub_table = table2;
00517     filehandle_stub_table_pos = 0;
00518 
00519     at.flush();
00520     at.clear_error();
00521     at.resp_start();
00522     at.read_bytes(buf2, 1);
00523     CHECK(1 == at.read_string(buf, 5, true));
00524 
00525     char table3[] = "sss\rsss\0";
00526     filehandle_stub_table = table3;
00527     filehandle_stub_table_pos = 0;
00528 
00529     at.flush();
00530     at.clear_error();
00531     at.resp_start("s");
00532     at.read_string(buf, 5, true);
00533 
00534     char table4[] = "\"s\"\0";
00535     filehandle_stub_table = table4;
00536     filehandle_stub_table_pos = 0;
00537 
00538     at.flush();
00539     at.clear_error();
00540     at.resp_start("s");
00541     at.read_string(buf, 5, true);
00542 
00543     filehandle_stub_table = NULL;
00544     filehandle_stub_table_pos = 0;
00545 }
00546 
00547 void Test_ATHandler::test_ATHandler_read_int()
00548 {
00549     EventQueue que;
00550     FileHandle_stub fh1;
00551 
00552     ATHandler at(&fh1, que, 0, ",");
00553 
00554     int32_t ret= at.read_int();
00555     CHECK(-1 == ret);
00556 
00557     char table[] = "\",\"OK\r\n\0";
00558     filehandle_stub_table = table;
00559     filehandle_stub_table_pos = 0;
00560 
00561     at.flush();
00562     at.clear_error();
00563     at.resp_start();
00564 
00565     ret= at.read_int();
00566     CHECK(-1 == ret);
00567 
00568     char table2[] = "\"2,\"OK\r\n\0";
00569     filehandle_stub_table = table2;
00570     filehandle_stub_table_pos = 0;
00571 
00572     at.flush();
00573     at.clear_error();
00574     at.resp_start();
00575 
00576     ret= at.read_int();
00577     CHECK(2 == ret);
00578 
00579 }
00580 
00581 void Test_ATHandler::test_ATHandler_resp_start()
00582 {
00583     EventQueue que;
00584     FileHandle_stub fh1;
00585 
00586     filehandle_stub_table = NULL;
00587     filehandle_stub_table_pos = 0;
00588 
00589     ATHandler at(&fh1, que, 0, ",");
00590     at.resp_start();
00591     at.resp_start();
00592 
00593     char table2[] = "\"2,\"OK\r\n\0";
00594     filehandle_stub_table = table2;
00595     filehandle_stub_table_pos = 0;
00596 
00597     at.flush();
00598     at.clear_error();
00599     at.resp_start("ssssaaaassssaaaassss"); //too long prefix
00600 
00601     char table3[] = "+CME ERROR: 108\0";
00602     filehandle_stub_table = table3;
00603     filehandle_stub_table_pos = 0;
00604 
00605     at.flush();
00606     at.clear_error();
00607     at.resp_start();
00608 
00609     filehandle_stub_table_pos = 0;
00610 
00611     at.flush();
00612     at.clear_error();
00613     at.resp_start();
00614 
00615     char table4[] = "+CMS ERROR: 6\0";
00616     filehandle_stub_table = table4;
00617     filehandle_stub_table_pos = 0;
00618 
00619     at.flush();
00620     at.clear_error();
00621     at.resp_start();
00622 
00623     char table5[] = "ERROR\r\n\0";
00624     filehandle_stub_table = table5;
00625     filehandle_stub_table_pos = 0;
00626 
00627     at.flush();
00628     at.clear_error();
00629     at.resp_start();
00630 
00631     char table6[] = "OK\r\n\0";
00632     filehandle_stub_table = table6;
00633     filehandle_stub_table_pos = 0;
00634 
00635     at.flush();
00636     at.clear_error();
00637     at.resp_start();
00638 
00639     char table7[] = "ssssss\0";
00640     filehandle_stub_table = table7;
00641     filehandle_stub_table_pos = 0;
00642 
00643     at.flush();
00644     at.clear_error();
00645     at.set_urc_handler("ss", NULL);
00646     at.resp_start();
00647 }
00648 
00649 void Test_ATHandler::test_ATHandler_resp_stop()
00650 {
00651     EventQueue que;
00652     FileHandle_stub fh1;
00653 
00654     ATHandler at(&fh1, que, 0, ",");
00655 
00656     char table[] = "21 OK\r\n\0";
00657     filehandle_stub_table = table;
00658     filehandle_stub_table_pos = 0;
00659 
00660     at.info_elem('2');
00661     at.set_stop_tag("OK\r\n");
00662     at.resp_stop();
00663 
00664     char table3[] = "+CME ERROR: 108\0";
00665     filehandle_stub_table = table3;
00666     filehandle_stub_table_pos = 0;
00667 
00668     at.flush();
00669     at.clear_error();
00670     at.resp_start();
00671 
00672     at.resp_stop();
00673 
00674     char table7[] = "ssssss\0";
00675     filehandle_stub_table = table7;
00676     filehandle_stub_table_pos = 0;
00677 
00678     at.flush();
00679     at.clear_error();
00680     at.resp_start("ss", false);
00681     at.resp_stop();
00682 }
00683 
00684 void Test_ATHandler::test_ATHandler_info_resp()
00685 {
00686     EventQueue que;
00687     FileHandle_stub fh1;
00688 
00689     filehandle_stub_table = NULL;
00690 
00691     ATHandler at(&fh1, que, 0, ",");
00692     CHECK(at.info_resp());
00693 
00694     at.resp_start();
00695     CHECK(!at.info_resp());
00696 
00697     char table2[] = "21 OK\r\n\0";
00698     filehandle_stub_table = table2;
00699     filehandle_stub_table_pos = 0;
00700 
00701     at.flush();
00702     at.clear_error();
00703     at.resp_start("21");
00704     CHECK(at.info_resp());
00705 
00706     CHECK(!at.info_resp());
00707 
00708     char table3[] = "21 OK\r\n\0";
00709     filehandle_stub_table = table3;
00710     filehandle_stub_table_pos = 0;
00711 
00712     at.flush();
00713     at.clear_error();
00714     CHECK(at.info_resp());
00715 }
00716 
00717 void Test_ATHandler::test_ATHandler_info_elem()
00718 {
00719     EventQueue que;
00720     FileHandle_stub fh1;
00721 
00722     char table[] = "21 OK\r\n\0";
00723     filehandle_stub_table = table;
00724     filehandle_stub_table_pos = 0;
00725 
00726     ATHandler at(&fh1, que, 0, ",");
00727     CHECK(!at.info_elem(char(79)));
00728 
00729     char table2[] = "21 OK\r\n\0";
00730     filehandle_stub_table = table2;
00731     filehandle_stub_table_pos = 0;
00732 
00733     at.flush();
00734     at.clear_error();
00735     at.resp_start("21");
00736     CHECK(at.info_elem(char(79)));
00737 
00738     CHECK(at.info_elem('2'));
00739 
00740     filehandle_stub_table = NULL;
00741     filehandle_stub_table_pos = 0;
00742 
00743     at.flush();
00744     at.clear_error();
00745     at.resp_start("21");
00746     CHECK(!at.info_elem('2'));
00747 }
00748 
00749 void Test_ATHandler::test_ATHandler_consume_to_stop_tag()
00750 {
00751     EventQueue que;
00752     FileHandle_stub fh1;
00753 
00754     ATHandler at(&fh1, que, 0, ",");
00755     CHECK(at.consume_to_stop_tag());
00756 }
00757 
00758 void Test_ATHandler::test_ATHandler_enable_debug()
00759 {
00760     EventQueue que;
00761     FileHandle_stub fh1;
00762 
00763     ATHandler at(&fh1, que, 0, ",");
00764     at.enable_debug(true);
00765 
00766     at.enable_debug(false);
00767 }
00768 
00769 void Test_ATHandler::test_ATHandler_get_3gpp_error()
00770 {
00771     EventQueue que;
00772     FileHandle_stub fh1;
00773 
00774     ATHandler at(&fh1, que, 0, ",");
00775     int ret = at.get_3gpp_error();
00776 }