test_at_cellularstack.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_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     int max_packet_size;
00038     CellularSocket socket;
00039 
00040     MyStack(ATHandler &atr, int cid, nsapi_ip_stack_t typ) : AT_CellularStack(atr, cid, typ)
00041     {
00042         bool_value = false;
00043         max_sock_value = 0;
00044         create_error = NSAPI_ERROR_OK ;
00045         max_packet_size = 0;
00046     }
00047 
00048     virtual int get_max_socket_count(){return max_sock_value;}
00049 
00050     virtual int get_max_packet_size(){return max_packet_size;}
00051 
00052     virtual bool is_protocol_supported(nsapi_protocol_t protocol){return bool_value;}
00053 
00054     virtual nsapi_error_t socket_close_impl(int sock_id){return NSAPI_ERROR_OK ;}
00055 
00056     virtual nsapi_error_t create_socket_impl(CellularSocket *socket){return create_error;}
00057 
00058     virtual nsapi_size_or_error_t socket_sendto_impl(CellularSocket *socket, const SocketAddress &address,
00059             const void *data, nsapi_size_t size){return NSAPI_ERROR_OK ;}
00060 
00061     virtual nsapi_size_or_error_t socket_recvfrom_impl(CellularSocket *socket, SocketAddress *address,
00062             void *buffer, nsapi_size_t size) {return NSAPI_ERROR_OK ;}
00063 
00064     virtual nsapi_error_t socket_open(nsapi_socket_t *handle, nsapi_protocol_t proto) {return AT_CellularStack::socket_open(handle, proto);}
00065 
00066     virtual nsapi_error_t socket_close(nsapi_socket_t handle) {return AT_CellularStack::socket_close(handle);}
00067 
00068     virtual nsapi_error_t socket_bind(nsapi_socket_t handle, const SocketAddress &address) {return AT_CellularStack::socket_bind(handle, address);}
00069 
00070     virtual nsapi_error_t socket_listen(nsapi_socket_t handle, int backlog) {return AT_CellularStack::socket_listen(handle, backlog);}
00071 
00072     virtual nsapi_error_t socket_connect(nsapi_socket_t handle, const SocketAddress &address) {return AT_CellularStack::socket_connect(handle, address);}
00073 
00074     virtual nsapi_error_t socket_accept(nsapi_socket_t server,
00075                                         nsapi_socket_t *handle, SocketAddress *address=0) {return AT_CellularStack::socket_accept(server, handle, address);}
00076 
00077     virtual nsapi_size_or_error_t socket_send(nsapi_socket_t handle,
00078             const void *data, nsapi_size_t size) {return AT_CellularStack::socket_send(handle, data, size);}
00079 
00080     virtual nsapi_size_or_error_t socket_recv(nsapi_socket_t handle,
00081             void *data, nsapi_size_t size) {return AT_CellularStack::socket_recv(handle, data, size);}
00082 
00083     virtual nsapi_size_or_error_t socket_sendto(nsapi_socket_t handle, const SocketAddress &address,
00084             const void *data, nsapi_size_t size) {return AT_CellularStack::socket_sendto(handle, address, data, size);}
00085 
00086     virtual nsapi_size_or_error_t socket_recvfrom(nsapi_socket_t handle, SocketAddress *address,
00087             void *buffer, nsapi_size_t size) {return AT_CellularStack::socket_recvfrom(handle, address, buffer, size);}
00088 
00089     virtual void socket_attach(nsapi_socket_t handle, void (*callback)(void *), void *data) {return AT_CellularStack::socket_attach(handle, callback, data);}
00090 };
00091 
00092 Test_AT_CellularStack::Test_AT_CellularStack()
00093 {
00094     ATHandler_stub::ssize_value = 0;
00095     ATHandler_stub::bool_value = false;
00096     ATHandler_stub::read_string_value = NULL;
00097 }
00098 
00099 Test_AT_CellularStack::~Test_AT_CellularStack()
00100 {
00101 }
00102 
00103 void Test_AT_CellularStack::test_AT_CellularStack_constructor()
00104 {
00105     EventQueue que;
00106     FileHandle_stub fh1;
00107     ATHandler at(&fh1, que, 0, ",");
00108 
00109     MyStack *st = new MyStack(at, 0, IPV4_STACK);
00110 
00111     delete st;
00112 }
00113 
00114 void Test_AT_CellularStack::test_AT_CellularStack_get_ip_address()
00115 {
00116     EventQueue que;
00117     FileHandle_stub fh1;
00118     ATHandler at(&fh1, que, 0, ",");
00119 
00120     MyStack st(at, 0, IPV6_STACK);
00121     CHECK(0 == strlen(st.get_ip_address()));
00122 
00123     char table[] = "1.2.3.4.5.65.7.8.9.10.11\0";
00124     ATHandler_stub::ssize_value = -1;
00125     ATHandler_stub::bool_value = true;
00126     ATHandler_stub::read_string_value = table;
00127     CHECK(NULL == st.get_ip_address());
00128 
00129     ATHandler_stub::ssize_value = strlen(table);
00130     ATHandler_stub::bool_value = true;
00131     ATHandler_stub::read_string_value = table;
00132     CHECK(st.get_ip_address());
00133 }
00134 
00135 void Test_AT_CellularStack::test_AT_CellularStack_socket_open()
00136 {
00137     EventQueue que;
00138     FileHandle_stub fh1;
00139     ATHandler at(&fh1, que, 0, ",");
00140 
00141     MyStack st(at, 0, IPV6_STACK);
00142     st.bool_value = false;
00143     CHECK(NSAPI_ERROR_UNSUPPORTED  == st.socket_open(NULL, NSAPI_TCP ));
00144 
00145     st.bool_value = true;
00146     st.max_sock_value = 0;
00147     nsapi_socket_t sock = &st.socket;
00148     CHECK(NSAPI_ERROR_NO_SOCKET  == st.socket_open(&sock, NSAPI_TCP ));
00149 
00150     MyStack st2(at, 0, IPV6_STACK);
00151     st2.bool_value = true;
00152     st2.max_sock_value = 1;
00153     sock = &st2.socket;
00154     CHECK(NSAPI_ERROR_OK  == st2.socket_open(&sock, NSAPI_TCP ));
00155 }
00156 
00157 void Test_AT_CellularStack::test_AT_CellularStack_socket_close()
00158 {
00159     EventQueue que;
00160     FileHandle_stub fh1;
00161     ATHandler at(&fh1, que, 0, ",");
00162 
00163     MyStack st(at, 0, IPV6_STACK);
00164     CHECK(NSAPI_ERROR_DEVICE_ERROR  == st.socket_close(&st.socket));
00165 
00166     nsapi_socket_t sock = &st.socket;
00167     st.bool_value = true;
00168     st.max_sock_value = 1;
00169     CHECK(NSAPI_ERROR_OK  == st.socket_open(&sock, NSAPI_TCP ));
00170     st.max_sock_value = 0;
00171     CHECK(NSAPI_ERROR_DEVICE_ERROR  == st.socket_close(sock));
00172 
00173     MyStack st2(at, 0, IPV6_STACK);
00174     st2.max_sock_value = 1;
00175     st2.bool_value = true;
00176     sock = &st2.socket;
00177     CHECK(NSAPI_ERROR_OK  == st2.socket_open(&sock, NSAPI_TCP ));
00178     CHECK(NSAPI_ERROR_OK  == st2.socket_close(sock));
00179 }
00180 
00181 void Test_AT_CellularStack::test_AT_CellularStack_socket_bind()
00182 {
00183     EventQueue que;
00184     FileHandle_stub fh1;
00185     ATHandler at(&fh1, que, 0, ",");
00186 
00187     MyStack st(at, 0, IPV6_STACK);
00188     SocketAddress addr;
00189     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_ALREADY ;
00190     CHECK(NSAPI_ERROR_DEVICE_ERROR  == st.socket_bind(NULL, addr));
00191 
00192     CHECK(NSAPI_ERROR_ALREADY  == st.socket_bind(&st.socket, addr));
00193 }
00194 
00195 void Test_AT_CellularStack::test_AT_CellularStack_socket_listen()
00196 {
00197     EventQueue que;
00198     FileHandle_stub fh1;
00199     ATHandler at(&fh1, que, 0, ",");
00200 
00201     MyStack st(at, 0, IPV6_STACK);
00202     CHECK(NSAPI_ERROR_UNSUPPORTED  == st.socket_listen(&st.socket, 4));
00203 }
00204 
00205 void Test_AT_CellularStack::test_AT_CellularStack_socket_connect()
00206 {
00207     EventQueue que;
00208     FileHandle_stub fh1;
00209     ATHandler at(&fh1, que, 0, ",");
00210 
00211     MyStack st(at, 0, IPV6_STACK);
00212     SocketAddress addr;
00213     CHECK(NSAPI_ERROR_DEVICE_ERROR  == st.socket_connect(NULL, addr));
00214 
00215     CHECK(NSAPI_ERROR_OK  == st.socket_connect(&st.socket, addr));
00216 }
00217 
00218 void Test_AT_CellularStack::test_AT_CellularStack_socket_accept()
00219 {
00220     EventQueue que;
00221     FileHandle_stub fh1;
00222     ATHandler at(&fh1, que, 0, ",");
00223 
00224     MyStack st(at, 0, IPV6_STACK);
00225     nsapi_socket_t sock = &st.socket;
00226     CHECK(NSAPI_ERROR_UNSUPPORTED  == st.socket_accept(NULL, &sock));
00227 }
00228 
00229 void Test_AT_CellularStack::test_AT_CellularStack_socket_send()
00230 {
00231     EventQueue que;
00232     FileHandle_stub fh1;
00233     ATHandler at(&fh1, que, 0, ",");
00234 
00235     MyStack st(at, 0, IPV6_STACK);
00236     CHECK(NSAPI_ERROR_DEVICE_ERROR  == st.socket_send(NULL, "addr", 4));
00237 
00238     CHECK(NSAPI_ERROR_DEVICE_ERROR  == st.socket_send(&st.socket, "addr", 4));
00239 
00240     SocketAddress addr;
00241     st.max_sock_value = 1;
00242     st.bool_value = true;
00243     nsapi_socket_t sock = &st.socket;
00244     st.socket_open(&sock, NSAPI_TCP );
00245     st.socket_connect(sock, addr);
00246     CHECK(NSAPI_ERROR_DEVICE_ERROR  == st.socket_send(sock, "addr", 4));
00247 }
00248 
00249 void Test_AT_CellularStack::test_AT_CellularStack_socket_sendto()
00250 {
00251     EventQueue que;
00252     FileHandle_stub fh1;
00253     ATHandler at(&fh1, que, 0, ",");
00254 
00255     MyStack st(at, 0, IPV6_STACK);
00256 
00257     SocketAddress addr;
00258     CHECK(NSAPI_ERROR_DEVICE_ERROR  == st.socket_sendto(NULL, addr, "addr", 4));
00259 
00260     st.max_sock_value = 1;
00261     st.bool_value = true;
00262     nsapi_socket_t sock = &st.socket;
00263     st.socket_open(&sock, NSAPI_TCP );
00264     st.socket_connect(sock, addr);
00265     st.create_error = NSAPI_ERROR_CONNECTION_LOST ;
00266     CHECK(NSAPI_ERROR_CONNECTION_LOST  == st.socket_sendto(sock, addr, "addr", 4));
00267 
00268     st.create_error = NSAPI_ERROR_OK ;
00269     st.max_packet_size = 6;
00270     CHECK(NSAPI_ERROR_OK  == st.socket_sendto(sock, addr, "addr", 4));
00271 }
00272 
00273 void Test_AT_CellularStack::test_AT_CellularStack_socket_recv()
00274 {
00275     EventQueue que;
00276     FileHandle_stub fh1;
00277     ATHandler at(&fh1, que, 0, ",");
00278 
00279     MyStack st(at, 0, IPV6_STACK);
00280     char table[4];
00281     CHECK(NSAPI_ERROR_DEVICE_ERROR  == st.socket_recv(NULL, table, 4));
00282 }
00283 
00284 void Test_AT_CellularStack::test_AT_CellularStack_socket_recvfrom()
00285 {
00286     EventQueue que;
00287     FileHandle_stub fh1;
00288     ATHandler at(&fh1, que, 0, ",");
00289 
00290     MyStack st(at, 0, IPV6_STACK);
00291     char table[4];
00292     CHECK(NSAPI_ERROR_DEVICE_ERROR  == st.socket_recvfrom(NULL, NULL, table, 4));
00293 
00294     SocketAddress addr;
00295     st.max_sock_value = 1;
00296     st.bool_value = true;
00297     nsapi_socket_t sock = &st.socket;
00298     st.socket_open(&sock, NSAPI_TCP );
00299     st.socket_connect(sock, addr);
00300     st.create_error = NSAPI_ERROR_CONNECTION_LOST ;
00301     CHECK(NSAPI_ERROR_CONNECTION_LOST  == st.socket_recvfrom(sock, &addr, table, 4));
00302 
00303     st.create_error = NSAPI_ERROR_OK ;
00304     st.max_packet_size = 6;
00305     CHECK(NSAPI_ERROR_OK  == st.socket_recvfrom(sock, &addr, table, 4));
00306 }
00307 
00308 void Test_AT_CellularStack::test_AT_CellularStack_socket_attach()
00309 {
00310     EventQueue que;
00311     FileHandle_stub fh1;
00312     ATHandler at(&fh1, que, 0, ",");
00313 
00314     MyStack st(at, 0, IPV6_STACK);
00315 
00316     st.socket_attach(NULL, NULL, NULL);
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_attach(sock, NULL, NULL);
00322 }