test_TCPSocket.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/TCPSocket.h"
00020 #include "NetworkStack_stub.h"
00021 
00022 // Control the rtos EventFlags stub. See EventFlags_stub.cpp
00023 extern std::list<uint32_t> eventFlagsStubNextRetval;
00024 
00025 // To test protected functions
00026 class TCPSocketFriend : public TCPSocket {
00027     friend class TestTCPSocket;
00028     FRIEND_TEST(TestTCPSocket, get_proto);
00029 };
00030 
00031 class TestTCPSocket : public testing::Test {
00032 public:
00033     unsigned int dataSize = 10;
00034     char dataBuf[10];
00035 protected:
00036     TCPSocket *socket;
00037     NetworkStackstub stack;
00038 
00039     virtual void SetUp()
00040     {
00041         socket = new TCPSocket();
00042     }
00043 
00044     virtual void TearDown()
00045     {
00046         stack.return_values.clear();
00047         eventFlagsStubNextRetval.clear();
00048         delete socket;
00049     }
00050 };
00051 
00052 TEST_F(TestTCPSocket, get_proto)
00053 {
00054     TCPSocketFriend tcpFriend;
00055     EXPECT_EQ(tcpFriend.get_proto(), NSAPI_TCP );
00056 }
00057 
00058 TEST_F(TestTCPSocket, constructor)
00059 {
00060     EXPECT_TRUE(socket);
00061 }
00062 
00063 TEST_F(TestTCPSocket, constructor_parameters)
00064 {
00065     TCPSocket socketParam = TCPSocket(dynamic_cast<NetworkStack*>(&stack));
00066     const SocketAddress a("127.0.0.1", 1024);
00067     EXPECT_EQ(socketParam.connect(a), NSAPI_ERROR_OK );
00068 }
00069 
00070 /* connect */
00071 
00072 TEST_F(TestTCPSocket, connect)
00073 {
00074     socket->open((NetworkStack *)&stack);
00075 
00076     stack.return_value = NSAPI_ERROR_OK ;
00077     const SocketAddress a("127.0.0.1", 1024);
00078     EXPECT_EQ(socket->connect(a), NSAPI_ERROR_OK );
00079 }
00080 
00081 TEST_F(TestTCPSocket, connect_no_open)
00082 {
00083     stack.return_value = NSAPI_ERROR_OK ;
00084     const SocketAddress a("127.0.0.1", 1024);
00085     EXPECT_EQ(socket->connect(a), NSAPI_ERROR_NO_SOCKET );
00086 }
00087 
00088 TEST_F(TestTCPSocket, connect_error_in_progress_no_timeout)
00089 {
00090     socket->open((NetworkStack *)&stack);
00091     stack.return_value = NSAPI_ERROR_IN_PROGRESS ;
00092     const SocketAddress a("127.0.0.1", 1024);
00093     eventFlagsStubNextRetval.push_back(osFlagsError); // Break the wait loop
00094     EXPECT_EQ(socket->connect(a), NSAPI_ERROR_IN_PROGRESS );
00095 }
00096 
00097 TEST_F(TestTCPSocket, connect_with_timeout)
00098 {
00099     socket->open((NetworkStack *)&stack);
00100     stack.return_value = NSAPI_ERROR_IN_PROGRESS ;
00101     const SocketAddress a("127.0.0.1", 1024);
00102     eventFlagsStubNextRetval.push_back(osFlagsError); // Break the wait loop
00103     socket->set_blocking(true);
00104     EXPECT_EQ(socket->connect(a), NSAPI_ERROR_IN_PROGRESS );
00105 }
00106 
00107 TEST_F(TestTCPSocket, connect_error_is_connected)
00108 {
00109     socket->open((NetworkStack *)&stack);
00110     stack.return_values.push_back(NSAPI_ERROR_ALREADY );
00111     stack.return_values.push_back(NSAPI_ERROR_IS_CONNECTED );
00112     const SocketAddress a("127.0.0.1", 1024);
00113     socket->set_timeout(1);
00114     EXPECT_EQ(socket->connect(a), NSAPI_ERROR_OK );
00115 }
00116 
00117 TEST_F(TestTCPSocket, connect_by_name_and_port)
00118 {
00119     socket->open((NetworkStack *)&stack);
00120     stack.return_value = NSAPI_ERROR_OK ;
00121     EXPECT_EQ(socket->connect("testhost", 80), NSAPI_ERROR_OK );
00122 }
00123 
00124 TEST_F(TestTCPSocket, connect_by_name_and_port_dns_fail)
00125 {
00126     socket->open((NetworkStack *)&stack);
00127     stack.return_value = NSAPI_ERROR_DNS_FAILURE ;
00128     EXPECT_EQ(socket->connect("testhost", 80), NSAPI_ERROR_DNS_FAILURE );
00129 }
00130 
00131 /* send */
00132 
00133 TEST_F(TestTCPSocket, send_no_open)
00134 {
00135     stack.return_value = NSAPI_ERROR_OK ;
00136     EXPECT_EQ(socket->send(dataBuf, dataSize), NSAPI_ERROR_NO_SOCKET );
00137 }
00138 
00139 TEST_F(TestTCPSocket, send_in_one_chunk)
00140 {
00141     socket->open((NetworkStack *)&stack);
00142     stack.return_value = dataSize;
00143     EXPECT_EQ(socket->send(dataBuf, dataSize), dataSize);
00144 }
00145 
00146 TEST_F(TestTCPSocket, send_in_two_chunks)
00147 {
00148     socket->open((NetworkStack *)&stack);
00149     stack.return_values.push_back(4);
00150     stack.return_values.push_back(dataSize - 4);
00151     EXPECT_EQ(socket->send(dataBuf, dataSize), dataSize);
00152 }
00153 
00154 TEST_F(TestTCPSocket, send_error_would_block)
00155 {
00156     socket->open((NetworkStack *)&stack);
00157     stack.return_value = NSAPI_ERROR_WOULD_BLOCK ;
00158     eventFlagsStubNextRetval.push_back(osFlagsError); // Break the wait loop
00159     EXPECT_EQ(socket->send(dataBuf, dataSize), NSAPI_ERROR_WOULD_BLOCK );
00160 }
00161 
00162 TEST_F(TestTCPSocket, send_error_other)
00163 {
00164     socket->open((NetworkStack *)&stack);
00165     stack.return_value = NSAPI_ERROR_NO_MEMORY ;
00166     EXPECT_EQ(socket->send(dataBuf, dataSize), NSAPI_ERROR_NO_MEMORY );
00167 }
00168 
00169 TEST_F(TestTCPSocket, send_error_no_timeout)
00170 {
00171     socket->open((NetworkStack *)&stack);
00172     stack.return_value = NSAPI_ERROR_WOULD_BLOCK ;
00173     socket->set_blocking(false);
00174     EXPECT_EQ(socket->send(dataBuf, dataSize), NSAPI_ERROR_WOULD_BLOCK );
00175 }
00176 
00177 TEST_F(TestTCPSocket, send_to)
00178 {
00179     socket->open((NetworkStack *)&stack);
00180     stack.return_value = 10;
00181     const SocketAddress a("127.0.0.1", 1024);
00182     EXPECT_EQ(socket->sendto(a, dataBuf, dataSize), dataSize);
00183 }
00184 
00185 /* recv */
00186 
00187 TEST_F(TestTCPSocket, recv_no_open)
00188 {
00189     stack.return_value = NSAPI_ERROR_OK ;
00190     EXPECT_EQ(socket->recv(dataBuf, dataSize), NSAPI_ERROR_NO_SOCKET );
00191 }
00192 
00193 TEST_F(TestTCPSocket, recv_all_data)
00194 {
00195     socket->open((NetworkStack *)&stack);
00196     stack.return_value = dataSize;
00197     EXPECT_EQ(socket->recv(dataBuf, dataSize), dataSize);
00198 }
00199 
00200 TEST_F(TestTCPSocket, recv_less_than_expected)
00201 {
00202     socket->open((NetworkStack *)&stack);
00203     unsigned int lessThanDataSize = dataSize -1;
00204     stack.return_values.push_back(lessThanDataSize);
00205     EXPECT_EQ(socket->recv(dataBuf, dataSize), lessThanDataSize);
00206 }
00207 
00208 TEST_F(TestTCPSocket, recv_would_block)
00209 {
00210     socket->open((NetworkStack *)&stack);
00211     stack.return_value = NSAPI_ERROR_WOULD_BLOCK ;
00212     eventFlagsStubNextRetval.push_back(0);
00213     eventFlagsStubNextRetval.push_back(osFlagsError); // Break the wait loop
00214     EXPECT_EQ(socket->recv(dataBuf, dataSize), NSAPI_ERROR_WOULD_BLOCK );
00215 }
00216 
00217 TEST_F(TestTCPSocket, recv_from_no_socket)
00218 {
00219     stack.return_value = NSAPI_ERROR_OK ;
00220     SocketAddress a("127.0.0.1", 1024);
00221     EXPECT_EQ(socket->recvfrom(&a, dataBuf, dataSize), NSAPI_ERROR_NO_SOCKET );
00222 }
00223 
00224 TEST_F(TestTCPSocket, recv_from)
00225 {
00226     stack.return_value = NSAPI_ERROR_OK ;
00227     SocketAddress a("127.0.0.1", 1024);
00228     EXPECT_EQ(socket->open((NetworkStack *)&stack), NSAPI_ERROR_OK );
00229     EXPECT_EQ(socket->connect(a), NSAPI_ERROR_OK );
00230     SocketAddress b;
00231     EXPECT_EQ(socket->recvfrom(&b, dataBuf, dataSize), NSAPI_ERROR_OK );
00232     EXPECT_EQ(a, b);
00233 }
00234 
00235 TEST_F(TestTCPSocket, recv_from_null)
00236 {
00237     stack.return_value = NSAPI_ERROR_OK ;
00238     SocketAddress a("127.0.0.1", 1024);
00239     EXPECT_EQ(socket->open((NetworkStack *)&stack), NSAPI_ERROR_OK );
00240     EXPECT_EQ(socket->connect(a), NSAPI_ERROR_OK );
00241     EXPECT_EQ(socket->recvfrom(NULL, dataBuf, dataSize), NSAPI_ERROR_OK );
00242 }
00243 
00244 /* listen */
00245 
00246 TEST_F(TestTCPSocket, listen_no_open)
00247 {
00248     stack.return_value = NSAPI_ERROR_OK ;
00249     EXPECT_EQ(socket->listen(1), NSAPI_ERROR_NO_SOCKET );
00250 }
00251 
00252 TEST_F(TestTCPSocket, listen)
00253 {
00254     stack.return_value = NSAPI_ERROR_OK ;
00255     socket->open((NetworkStack *)&stack);
00256     EXPECT_EQ(socket->listen(1), NSAPI_ERROR_OK );
00257 }
00258 
00259 /* these tests will have to be readjusted after TCPServer is deprecated. */
00260 
00261 TEST_F(TestTCPSocket, accept_no_open)
00262 {
00263     nsapi_error_t error;
00264     stack.return_value = NSAPI_ERROR_OK ;
00265     EXPECT_EQ(socket->accept(&error), static_cast<TCPSocket*>(NULL));
00266     EXPECT_EQ(error, NSAPI_ERROR_NO_SOCKET );
00267 }
00268 
00269 TEST_F(TestTCPSocket, accept)
00270 {
00271     nsapi_error_t error;
00272     stack.return_value = NSAPI_ERROR_OK ;
00273     socket->open((NetworkStack *)&stack);
00274     EXPECT_NE(socket->accept(&error), static_cast<TCPSocket*>(NULL));
00275     EXPECT_EQ(error, NSAPI_ERROR_OK );
00276 }
00277 
00278 TEST_F(TestTCPSocket, accept_would_block)
00279 {
00280     nsapi_error_t error;
00281     socket->open((NetworkStack *)&stack);
00282     stack.return_value = NSAPI_ERROR_WOULD_BLOCK ;
00283     eventFlagsStubNextRetval.push_back(0);
00284     eventFlagsStubNextRetval.push_back(osFlagsError); // Break the wait loop
00285     EXPECT_EQ(socket->accept(&error), static_cast<TCPSocket*>(NULL));
00286     EXPECT_EQ(error, NSAPI_ERROR_WOULD_BLOCK );
00287 }