test_InternetSocket.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 
00018 #include "gtest/gtest.h"
00019 #include "features/netsocket/InternetSocket.h"
00020 #include "NetworkStack_stub.h"
00021 
00022 extern std::list<uint32_t> eventFlagsStubNextRetval;
00023 
00024 // InternetSocket is an abstract class, so we have to test it via its child.
00025 class stubInternetSocket : public InternetSocket {
00026 protected:
00027     nsapi_error_t return_value = 0;
00028 public:
00029     virtual nsapi_error_t connect(const SocketAddress &address)
00030     {
00031         return return_value;
00032     }
00033     virtual nsapi_size_or_error_t send(const void *data, nsapi_size_t size)
00034     {
00035         return return_value;
00036     }
00037     virtual nsapi_size_or_error_t recv(void *data, nsapi_size_t size)
00038     {
00039         return return_value;
00040     }
00041     virtual nsapi_size_or_error_t sendto(const SocketAddress &address,
00042                                          const void *data, nsapi_size_t size)
00043     {
00044         return return_value;
00045     }
00046     virtual nsapi_size_or_error_t recvfrom(SocketAddress *address,
00047                                            void *data, nsapi_size_t size)
00048     {
00049         return return_value;
00050     }
00051     virtual Socket *accept(nsapi_error_t *error = NULL)
00052     {
00053         return NULL;
00054     }
00055     virtual nsapi_error_t listen(int backlog = 1)
00056     {
00057         return return_value;
00058     }
00059 
00060     // Testing functions
00061     void add_reader (void) { _readers++;}
00062     void rem_reader (void) { _readers--;}
00063     void add_writer (void) { _writers++;}
00064     void rem_writer (void) { _writers--;}
00065     void add_pending (void) { _pending++;}
00066     void rem_pending (void) { _pending--;}
00067 
00068 protected:
00069     virtual nsapi_protocol_t get_proto()
00070     {
00071         return NSAPI_TCP ;
00072     }
00073 };
00074 
00075 static bool callback_is_called;
00076 static void my_callback()
00077 {
00078     callback_is_called = true;
00079 }
00080 
00081 class TestInternetSocket : public testing::Test {
00082 protected:
00083     stubInternetSocket *socket;
00084     NetworkStackstub stack;
00085 
00086     virtual void SetUp()
00087     {
00088         socket = new stubInternetSocket;
00089     }
00090 
00091     virtual void TearDown()
00092     {
00093         delete socket;
00094     }
00095 };
00096 
00097 TEST_F(TestInternetSocket, constructor)
00098 {
00099     EXPECT_TRUE(socket);
00100 }
00101 
00102 TEST_F(TestInternetSocket, open_null_stack)
00103 {
00104     EXPECT_EQ(socket->open(NULL), NSAPI_ERROR_PARAMETER );
00105 }
00106 
00107 TEST_F(TestInternetSocket, open_error)
00108 {
00109     stack.return_value = NSAPI_ERROR_PARAMETER ;
00110     EXPECT_EQ(socket->open((NetworkStack *)&stack), NSAPI_ERROR_PARAMETER );
00111 }
00112 
00113 TEST_F(TestInternetSocket, open)
00114 {
00115     stack.return_value = NSAPI_ERROR_OK ;
00116     EXPECT_EQ(socket->open((NetworkStack *)&stack), NSAPI_ERROR_OK );
00117 }
00118 
00119 TEST_F(TestInternetSocket, open_twice)
00120 {
00121     stack.return_value = NSAPI_ERROR_OK ;
00122     EXPECT_EQ(socket->open((NetworkStack *)&stack), NSAPI_ERROR_OK );
00123     EXPECT_EQ(socket->open((NetworkStack *)&stack), NSAPI_ERROR_PARAMETER );
00124 }
00125 
00126 TEST_F(TestInternetSocket, close)
00127 {
00128     stack.return_value = NSAPI_ERROR_OK ;
00129     socket->open((NetworkStack *)&stack);
00130     EXPECT_EQ(socket->close(), NSAPI_ERROR_OK );
00131 }
00132 
00133 TEST_F(TestInternetSocket, close_no_open)
00134 {
00135     stack.return_value = NSAPI_ERROR_OK ;
00136     EXPECT_EQ(socket->close(), NSAPI_ERROR_OK );
00137 }
00138 
00139 TEST_F(TestInternetSocket, close_during_read)
00140 {
00141     stack.return_value = NSAPI_ERROR_OK ;
00142     socket->open((NetworkStack *)&stack);
00143     // when c++11 is available use something like the code below to test the blocking behavior
00144     // socket->add_reader();
00145     // std::async(c[](){std::this_thread::sleep_for(1ms); socket->rem_reader()});
00146     EXPECT_EQ(socket->close(), NSAPI_ERROR_OK );
00147 }
00148 
00149 TEST_F(TestInternetSocket, modify_multicast_group)
00150 {
00151     SocketAddress a("127.0.0.1", 1024);
00152     stack.return_value = NSAPI_ERROR_OK ;
00153     socket->open((NetworkStack *)&stack);
00154     // when c++11 is available use something like the code below to test the blocking behavior
00155     // socket->add_reader();
00156     // std::async(c[](){std::this_thread::sleep_for(1ms); socket->rem_reader()});
00157     EXPECT_EQ(socket->join_multicast_group(a), NSAPI_ERROR_UNSUPPORTED );
00158     EXPECT_EQ(socket->leave_multicast_group(a), NSAPI_ERROR_UNSUPPORTED );
00159 }
00160 
00161 // set_blocking and set_timeout are tested within TCPSocket.
00162 
00163 TEST_F(TestInternetSocket, bind_no_socket)
00164 {
00165     EXPECT_EQ(socket->bind(1), NSAPI_ERROR_NO_SOCKET );
00166 }
00167 
00168 TEST_F(TestInternetSocket, bind)
00169 {
00170     socket->open((NetworkStack *)&stack);
00171     EXPECT_EQ(socket->bind("127.0.0.1", 80), NSAPI_ERROR_OK );
00172 }
00173 
00174 TEST_F(TestInternetSocket, bind_nullstring)
00175 {
00176     socket->open((NetworkStack *)&stack);
00177     EXPECT_EQ(socket->bind(NULL, 80), NSAPI_ERROR_OK );
00178 }
00179 
00180 // setsockopt and getsockopt are really just calling the underlying stack functions
00181 
00182 TEST_F(TestInternetSocket, setsockopt_no_stack)
00183 {
00184     EXPECT_EQ(socket->setsockopt(0, 0, 0, 0), NSAPI_ERROR_NO_SOCKET );
00185 }
00186 
00187 TEST_F(TestInternetSocket, setsockopt)
00188 {
00189     socket->open((NetworkStack *)&stack);
00190     EXPECT_EQ(socket->setsockopt(0, 0, 0, 0), NSAPI_ERROR_UNSUPPORTED );
00191 }
00192 
00193 TEST_F(TestInternetSocket, getsockopt_no_stack)
00194 {
00195     EXPECT_EQ(socket->getsockopt(0, 0, 0, 0), NSAPI_ERROR_NO_SOCKET );
00196 }
00197 
00198 TEST_F(TestInternetSocket, getsockopt)
00199 {
00200     socket->open((NetworkStack *)&stack);
00201     EXPECT_EQ(socket->getsockopt(0, 0, 0, 0), NSAPI_ERROR_UNSUPPORTED );
00202 }
00203 
00204 TEST_F(TestInternetSocket, sigio)
00205 {
00206     callback_is_called = false;
00207     socket->sigio(mbed::callback(my_callback));
00208     socket->close(); // Trigger event;
00209     EXPECT_EQ(callback_is_called, true);
00210 }