at_cellularsmstest.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 "ATHandler_stub.h"
00023 #include "AT_CellularSMS.h"
00024 #include "FileHandle_stub.h"
00025 #include "CellularLog.h"
00026 
00027 using namespace mbed;
00028 using namespace events;
00029 
00030 // AStyle ignored as the definition is not clear due to preprocessor usage
00031 // *INDENT-OFF*
00032 class TestAT_CellularSMS : public testing::Test {
00033 protected:
00034 
00035     void SetUp()
00036     {
00037         ATHandler_stub::return_given_size = false;
00038         ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00039     }
00040 
00041     void TearDown()
00042     {
00043     }
00044 };
00045 // *INDENT-ON*
00046 
00047 TEST_F(TestAT_CellularSMS, Create)
00048 {
00049     EventQueue que;
00050     FileHandle_stub fh1;
00051     ATHandler at(&fh1, que, 0, ",");
00052 
00053     AT_CellularSMS *sms = new AT_CellularSMS(at);
00054 
00055     EXPECT_TRUE(sms != NULL);
00056     delete sms;
00057 }
00058 
00059 void my_callback()
00060 {
00061 
00062 }
00063 
00064 TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_initialize)
00065 {
00066     EventQueue que;
00067     FileHandle_stub fh1;
00068     ATHandler at(&fh1, que, 0, ",");
00069 
00070     ATHandler_stub::call_immediately = true;
00071 
00072     AT_CellularSMS sms(at);
00073     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE ;
00074     EXPECT_TRUE(NSAPI_ERROR_NO_MEMORY  == sms.initialize(CellularSMS::CellularSMSMmodeText));
00075 
00076     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00077     EXPECT_TRUE(NSAPI_ERROR_OK  == sms.initialize(CellularSMS::CellularSMSMmodeText));
00078 
00079     sms.set_sms_callback(&my_callback);
00080     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00081     EXPECT_TRUE(NSAPI_ERROR_OK  == sms.initialize(CellularSMS::CellularSMSMmodeText));
00082 
00083     ATHandler_stub::call_immediately = false;
00084 }
00085 
00086 TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_send_sms)
00087 {
00088     EventQueue que;
00089     FileHandle_stub fh1;
00090     ATHandler at(&fh1, que, 0, ",");
00091 
00092     AT_CellularSMS sms(at);
00093     EXPECT_EQ(NSAPI_ERROR_PARAMETER , sms.send_sms(NULL, "2", 1));
00094 
00095     sms.initialize(CellularSMS::CellularSMSMmodeText);
00096     ATHandler_stub::size_value = 1;
00097     EXPECT_EQ(1, sms.send_sms("1", "22", 2));
00098 
00099     ATHandler_stub::size_value = 2;
00100     EXPECT_EQ(2, sms.send_sms("1", "22", 2));
00101 
00102     ATHandler_stub::return_given_size = true; // PDU mode write is much longer than than msg len
00103     sms.initialize(CellularSMS::CellularSMSMmodePDU);
00104     EXPECT_EQ(2, sms.send_sms("1", "23", 2));;
00105 
00106     ATHandler_stub::nsapi_error_ok_counter = 1;
00107     ATHandler_stub::size_value = 32;
00108     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE ;
00109     EXPECT_EQ(NSAPI_ERROR_AUTH_FAILURE , sms.send_sms("1", "23232323", 8));
00110 
00111     ATHandler_stub::nsapi_error_ok_counter = 2;
00112     ATHandler_stub::size_value = 32;
00113     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE ;
00114     EXPECT_EQ(NSAPI_ERROR_AUTH_FAILURE , sms.send_sms("1", "23232323", 8));
00115 
00116     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00117     char table[] = "232323232323232323232323232323232323232323232323232323\
00118                     232323232323232323232323232323232323232323232323232323\
00119                     232323232323232323232323232323232323232323232323232323\
00120                     23232323232323232323232323232323232323\0";
00121 
00122     EXPECT_EQ(strlen(table), sms.send_sms("1", table, strlen(table)));
00123     EXPECT_EQ(strlen(table), sms.send_sms("12", table, strlen(table)));
00124 }
00125 
00126 TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_get_sms)
00127 {
00128     EventQueue que;
00129     FileHandle_stub fh1;
00130     ATHandler at(&fh1, que, 0, ",");
00131 
00132     AT_CellularSMS sms(at);
00133     char buf[16];
00134     char phone[21];
00135     char stamp[21];
00136     int size;
00137     EXPECT_TRUE(NSAPI_ERROR_PARAMETER  == sms.get_sms(NULL, 16, phone, 21, stamp, 21, &size));
00138 
00139     ATHandler_stub::resp_info_true_counter = 1;
00140     ATHandler_stub::int_value = 0;
00141     EXPECT_TRUE(-1 == sms.get_sms(buf, 16, phone, 21, stamp, 21, &size));
00142 
00143     ATHandler_stub::resp_info_true_counter = 2;
00144     ATHandler_stub::int_value = 11;
00145     EXPECT_TRUE(0 == sms.get_sms(buf, 16, phone, 21, stamp, 21, &size));
00146     //TODO: Should make add_info to happen, before calling get_sms!
00147 
00148     ATHandler_stub::resp_info_true_counter = 2;
00149     ATHandler_stub::int_value = 11;
00150     sms.initialize(CellularSMS::CellularSMSMmodePDU);
00151     EXPECT_TRUE(0 == sms.get_sms(buf, 16, phone, 21, stamp, 21, &size));
00152 
00153     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE ;
00154     EXPECT_TRUE(NSAPI_ERROR_AUTH_FAILURE  == sms.get_sms(buf, 16, phone, 21, stamp, 21, &size));
00155 }
00156 
00157 TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_set_sms_callback)
00158 {
00159     EventQueue que;
00160     FileHandle_stub fh1;
00161     ATHandler at(&fh1, que, 0, ",");
00162 
00163     AT_CellularSMS sms(at);
00164     sms.set_sms_callback(NULL);
00165 }
00166 
00167 TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_set_cpms)
00168 {
00169     EventQueue que;
00170     FileHandle_stub fh1;
00171     ATHandler at(&fh1, que, 0, ",");
00172 
00173     AT_CellularSMS sms(at);
00174     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE ;
00175     EXPECT_TRUE(NSAPI_ERROR_AUTH_FAILURE  == sms.set_cpms("2", "3", "4"));
00176 }
00177 
00178 TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_set_csca)
00179 {
00180     EventQueue que;
00181     FileHandle_stub fh1;
00182     ATHandler at(&fh1, que, 0, ",");
00183 
00184     AT_CellularSMS sms(at);
00185     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE ;
00186     EXPECT_TRUE(NSAPI_ERROR_AUTH_FAILURE  == sms.set_csca("2", 1));
00187 }
00188 
00189 TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_set_cscs)
00190 {
00191     EventQueue que;
00192     FileHandle_stub fh1;
00193     ATHandler at(&fh1, que, 0, ",");
00194 
00195     AT_CellularSMS sms(at);
00196     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE ;
00197     EXPECT_TRUE(NSAPI_ERROR_AUTH_FAILURE  == sms.set_cscs("2"));
00198 }
00199 
00200 TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_delete_all_messages)
00201 {
00202     EventQueue que;
00203     FileHandle_stub fh1;
00204     ATHandler at(&fh1, que, 0, ",");
00205 
00206     AT_CellularSMS sms(at);
00207     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE ;
00208     EXPECT_TRUE(NSAPI_ERROR_AUTH_FAILURE  == sms.delete_all_messages());
00209 }
00210 
00211 TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_set_extra_sim_wait_time)
00212 {
00213     EventQueue que;
00214     FileHandle_stub fh1;
00215     ATHandler at(&fh1, que, 0, ",");
00216 
00217     AT_CellularSMS sms(at);
00218     sms.set_extra_sim_wait_time(56);
00219 }