at_cellularstacktest.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 "AT_CellularStack.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 "ATHandler_stub.h"
00027 #include "SocketAddress.h"
00028 
00029 using namespace mbed;
00030 using namespace events;
00031 
00032 class MyStack : public AT_CellularStack {
00033 public:
00034     bool bool_value;
00035     bool max_sock_value;
00036     nsapi_error_t create_error;
00037     CellularSocket socket;
00038 
00039     MyStack(ATHandler &atr, int cid, nsapi_ip_stack_t typ) : AT_CellularStack(atr, cid, typ)
00040     {
00041         bool_value = false;
00042         max_sock_value = 0;
00043         create_error = NSAPI_ERROR_OK ;
00044     }
00045 
00046     virtual int get_max_socket_count()
00047     {
00048         return max_sock_value;
00049     }
00050 
00051     virtual bool is_protocol_supported(nsapi_protocol_t protocol)
00052     {
00053         return bool_value;
00054     }
00055 
00056     virtual nsapi_error_t socket_close_impl(int sock_id)
00057     {
00058         return NSAPI_ERROR_OK ;
00059     }
00060 
00061     virtual nsapi_error_t create_socket_impl(CellularSocket *socket)
00062     {
00063         return create_error;
00064     }
00065 
00066     virtual nsapi_size_or_error_t socket_sendto_impl(CellularSocket *socket, const SocketAddress &address,
00067                                                      const void *data, nsapi_size_t size)
00068     {
00069         return NSAPI_ERROR_OK ;
00070     }
00071 
00072     virtual nsapi_size_or_error_t socket_recvfrom_impl(CellularSocket *socket, SocketAddress *address,
00073                                                        void *buffer, nsapi_size_t size)
00074     {
00075         return NSAPI_ERROR_OK ;
00076     }
00077 
00078     virtual nsapi_error_t socket_open(nsapi_socket_t *handle, nsapi_protocol_t proto)
00079     {
00080         return AT_CellularStack::socket_open(handle, proto);
00081     }
00082 
00083     virtual nsapi_error_t socket_close(nsapi_socket_t handle)
00084     {
00085         return AT_CellularStack::socket_close(handle);
00086     }
00087 
00088     virtual nsapi_error_t socket_bind(nsapi_socket_t handle, const SocketAddress &address)
00089     {
00090         return AT_CellularStack::socket_bind(handle, address);
00091     }
00092 
00093     virtual nsapi_error_t socket_listen(nsapi_socket_t handle, int backlog)
00094     {
00095         return AT_CellularStack::socket_listen(handle, backlog);
00096     }
00097 
00098     virtual nsapi_error_t socket_connect(nsapi_socket_t handle, const SocketAddress &address)
00099     {
00100         return AT_CellularStack::socket_connect(handle, address);
00101     }
00102 
00103     virtual nsapi_error_t socket_accept(nsapi_socket_t server,
00104                                         nsapi_socket_t *handle, SocketAddress *address = 0)
00105     {
00106         return AT_CellularStack::socket_accept(server, handle, address);
00107     }
00108 
00109     virtual nsapi_size_or_error_t socket_send(nsapi_socket_t handle,
00110                                               const void *data, nsapi_size_t size)
00111     {
00112         return AT_CellularStack::socket_send(handle, data, size);
00113     }
00114 
00115     virtual nsapi_size_or_error_t socket_recv(nsapi_socket_t handle,
00116                                               void *data, nsapi_size_t size)
00117     {
00118         return AT_CellularStack::socket_recv(handle, data, size);
00119     }
00120 
00121     virtual nsapi_size_or_error_t socket_sendto(nsapi_socket_t handle, const SocketAddress &address,
00122                                                 const void *data, nsapi_size_t size)
00123     {
00124         return AT_CellularStack::socket_sendto(handle, address, data, size);
00125     }
00126 
00127     virtual nsapi_size_or_error_t socket_recvfrom(nsapi_socket_t handle, SocketAddress *address,
00128                                                   void *buffer, nsapi_size_t size)
00129     {
00130         return AT_CellularStack::socket_recvfrom(handle, address, buffer, size);
00131     }
00132 
00133     virtual void socket_attach(nsapi_socket_t handle, void (*callback)(void *), void *data)
00134     {
00135         return AT_CellularStack::socket_attach(handle, callback, data);
00136     }
00137 };
00138 
00139 // AStyle ignored as the definition is not clear due to preprocessor usage
00140 // *INDENT-OFF*
00141 class TestAT_CellularStack : public testing::Test {
00142 protected:
00143 
00144     void SetUp()
00145     {
00146         ATHandler_stub::return_given_size = false;
00147         ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00148         ATHandler_stub::ssize_value = 0;
00149         ATHandler_stub::bool_value = false;
00150         ATHandler_stub::read_string_value = NULL;
00151     }
00152 
00153     void TearDown()
00154     {
00155     }
00156 };
00157 // *INDENT-ON*
00158 
00159 TEST_F(TestAT_CellularStack, Create)
00160 {
00161     EventQueue que;
00162     FileHandle_stub fh1;
00163     ATHandler at(&fh1, que, 0, ",");
00164 
00165     MyStack *st = new MyStack(at, 0, IPV4_STACK);
00166 
00167     EXPECT_TRUE(st != NULL);
00168     delete st;
00169 }
00170 
00171 TEST_F(TestAT_CellularStack, test_AT_CellularStack_get_ip_address)
00172 {
00173     EventQueue que;
00174     FileHandle_stub fh1;
00175     ATHandler at(&fh1, que, 0, ",");
00176 
00177     MyStack st(at, 0, IPV6_STACK);
00178     EXPECT_EQ(strlen(st.get_ip_address()), 0);
00179 
00180     char table[] = "1.2.3.4.5.65.7.8.9.10.11\0";
00181     ATHandler_stub::ssize_value = -1;
00182     ATHandler_stub::bool_value = true;
00183     ATHandler_stub::read_string_value = table;
00184     EXPECT_TRUE(st.get_ip_address() == NULL);
00185 
00186     ATHandler_stub::ssize_value = strlen(table);
00187     ATHandler_stub::bool_value = true;
00188     ATHandler_stub::read_string_value = table;
00189     EXPECT_TRUE(st.get_ip_address());
00190 }
00191 
00192 TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_open)
00193 {
00194     EventQueue que;
00195     FileHandle_stub fh1;
00196     ATHandler at(&fh1, que, 0, ",");
00197 
00198     MyStack st(at, 0, IPV6_STACK);
00199     st.bool_value = false;
00200     EXPECT_EQ(st.socket_open(NULL, NSAPI_TCP ), NSAPI_ERROR_UNSUPPORTED );
00201 
00202     st.bool_value = true;
00203     st.max_sock_value = 0;
00204     nsapi_socket_t sock = &st.socket;
00205     EXPECT_EQ(st.socket_open(&sock, NSAPI_TCP ), NSAPI_ERROR_NO_SOCKET );
00206 
00207     MyStack st2(at, 0, IPV6_STACK);
00208     st2.bool_value = true;
00209     st2.max_sock_value = 1;
00210     sock = &st2.socket;
00211     EXPECT_EQ(st2.socket_open(&sock, NSAPI_TCP ), NSAPI_ERROR_OK );
00212 }
00213 
00214 TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_close)
00215 {
00216     EventQueue que;
00217     FileHandle_stub fh1;
00218     ATHandler at(&fh1, que, 0, ",");
00219 
00220     MyStack st(at, 0, IPV6_STACK);
00221     EXPECT_EQ(st.socket_close(&st.socket), NSAPI_ERROR_DEVICE_ERROR );
00222 
00223     nsapi_socket_t sock = &st.socket;
00224     st.bool_value = true;
00225     st.max_sock_value = 1;
00226     EXPECT_EQ(st.socket_open(&sock, NSAPI_TCP ), NSAPI_ERROR_OK );
00227     st.max_sock_value = 0;
00228     EXPECT_EQ(st.socket_close(sock), NSAPI_ERROR_DEVICE_ERROR );
00229 
00230     MyStack st2(at, 0, IPV6_STACK);
00231     st2.max_sock_value = 1;
00232     st2.bool_value = true;
00233     sock = &st2.socket;
00234     EXPECT_EQ(st2.socket_open(&sock, NSAPI_TCP ), NSAPI_ERROR_OK );
00235     EXPECT_EQ(st2.socket_close(sock), NSAPI_ERROR_OK );
00236 }
00237 
00238 TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_bind)
00239 {
00240     EventQueue que;
00241     FileHandle_stub fh1;
00242     ATHandler at(&fh1, que, 0, ",");
00243 
00244     MyStack st(at, 0, IPV6_STACK);
00245     SocketAddress addr;
00246     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_ALREADY ;
00247     EXPECT_EQ(st.socket_bind(NULL, addr), NSAPI_ERROR_DEVICE_ERROR );
00248 
00249     EXPECT_EQ(st.socket_bind(&st.socket, addr), NSAPI_ERROR_ALREADY );
00250 }
00251 
00252 TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_listen)
00253 {
00254     EventQueue que;
00255     FileHandle_stub fh1;
00256     ATHandler at(&fh1, que, 0, ",");
00257 
00258     MyStack st(at, 0, IPV6_STACK);
00259     EXPECT_EQ(st.socket_listen(&st.socket, 4), NSAPI_ERROR_UNSUPPORTED );
00260 }
00261 
00262 TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_connect)
00263 {
00264     EventQueue que;
00265     FileHandle_stub fh1;
00266     ATHandler at(&fh1, que, 0, ",");
00267 
00268     MyStack st(at, 0, IPV6_STACK);
00269     SocketAddress addr;
00270     EXPECT_EQ(st.socket_connect(NULL, addr), NSAPI_ERROR_DEVICE_ERROR );
00271 
00272     EXPECT_EQ(st.socket_connect(&st.socket, addr), NSAPI_ERROR_OK );
00273 }
00274 
00275 TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_accept)
00276 {
00277     EventQueue que;
00278     FileHandle_stub fh1;
00279     ATHandler at(&fh1, que, 0, ",");
00280 
00281     MyStack st(at, 0, IPV6_STACK);
00282     nsapi_socket_t sock = &st.socket;
00283     EXPECT_EQ(st.socket_accept(NULL, &sock), NSAPI_ERROR_UNSUPPORTED );
00284 }
00285 
00286 TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_send)
00287 {
00288     EventQueue que;
00289     FileHandle_stub fh1;
00290     ATHandler at(&fh1, que, 0, ",");
00291 
00292     MyStack st(at, 0, IPV6_STACK);
00293     EXPECT_EQ(st.socket_send(NULL, "addr", 4), NSAPI_ERROR_DEVICE_ERROR );
00294 
00295     EXPECT_EQ(st.socket_send(&st.socket, "addr", 4), NSAPI_ERROR_DEVICE_ERROR );
00296 
00297     SocketAddress addr;
00298     st.max_sock_value = 1;
00299     st.bool_value = true;
00300     nsapi_socket_t sock = &st.socket;
00301     st.socket_open(&sock, NSAPI_TCP );
00302     st.socket_connect(sock, addr);
00303     EXPECT_EQ(st.socket_send(sock, "addr", 4), NSAPI_ERROR_OK );
00304 }
00305 
00306 TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_sendto)
00307 {
00308     EventQueue que;
00309     FileHandle_stub fh1;
00310     ATHandler at(&fh1, que, 0, ",");
00311 
00312     MyStack st(at, 0, IPV6_STACK);
00313 
00314     SocketAddress addr;
00315     EXPECT_EQ(st.socket_sendto(NULL, addr, "addr", 4), NSAPI_ERROR_DEVICE_ERROR );
00316 
00317     st.max_sock_value = 1;
00318     st.bool_value = true;
00319     nsapi_socket_t sock = &st.socket;
00320     st.socket_open(&sock, NSAPI_TCP );
00321     st.socket_connect(sock, addr);
00322     st.create_error = NSAPI_ERROR_CONNECTION_LOST ;
00323     EXPECT_EQ(st.socket_sendto(sock, addr, "addr", 4), NSAPI_ERROR_CONNECTION_LOST );
00324 
00325     st.create_error = NSAPI_ERROR_OK ;
00326     EXPECT_EQ(st.socket_sendto(sock, addr, "addr", 4), NSAPI_ERROR_OK );
00327 }
00328 
00329 TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_recv)
00330 {
00331     EventQueue que;
00332     FileHandle_stub fh1;
00333     ATHandler at(&fh1, que, 0, ",");
00334 
00335     MyStack st(at, 0, IPV6_STACK);
00336     char table[4];
00337     EXPECT_EQ(st.socket_recv(NULL, table, 4), NSAPI_ERROR_DEVICE_ERROR );
00338 }
00339 
00340 TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_recvfrom)
00341 {
00342     EventQueue que;
00343     FileHandle_stub fh1;
00344     ATHandler at(&fh1, que, 0, ",");
00345 
00346     MyStack st(at, 0, IPV6_STACK);
00347     char table[4];
00348     EXPECT_EQ(st.socket_recvfrom(NULL, NULL, table, 4), NSAPI_ERROR_DEVICE_ERROR );
00349 
00350     SocketAddress addr;
00351     st.max_sock_value = 1;
00352     st.bool_value = true;
00353     nsapi_socket_t sock = &st.socket;
00354     st.socket_open(&sock, NSAPI_TCP );
00355     st.socket_connect(sock, addr);
00356     st.create_error = NSAPI_ERROR_CONNECTION_LOST ;
00357     EXPECT_EQ(st.socket_recvfrom(sock, &addr, table, 4), NSAPI_ERROR_CONNECTION_LOST );
00358 
00359     st.create_error = NSAPI_ERROR_OK ;
00360     EXPECT_EQ(st.socket_recvfrom(sock, &addr, table, 4), NSAPI_ERROR_OK );
00361 }
00362 
00363 TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_attach)
00364 {
00365     EventQueue que;
00366     FileHandle_stub fh1;
00367     ATHandler at(&fh1, que, 0, ",");
00368 
00369     MyStack st(at, 0, IPV6_STACK);
00370 
00371     st.socket_attach(NULL, NULL, NULL);
00372     st.max_sock_value = 1;
00373     st.bool_value = true;
00374     nsapi_socket_t sock = &st.socket;
00375     st.socket_open(&sock, NSAPI_TCP );
00376     st.socket_attach(sock, NULL, NULL);
00377 }