Test Tcp Evita

apps/CMakeLists.txt

@@ -4,8 +4,10 @@ target_link_libraries(table.out PRIVATE ft_irc)
 add_executable(parser.out parser.cpp)
 target_link_libraries(parser.out PRIVATE ft_irc)
 
-add_executable(echo_server server.cpp)
-add_executable(echo_client client.cpp)
+add_executable(echo_server tcpAcceptor.cpp)
+add_executable(echo_client tcpConnector.cpp)
+add_executable(tcpStream.out tcpStream.cpp)
+
 add_executable(server multiserver.cpp)
 add_executable(irc irc.cpp)
 
@@ -17,3 +19,5 @@ target_link_libraries(irc PRIVATE ft_irc)
 
 add_executable(infinite_loop.out infinite_loop.cpp)
 add_executable(stop_loop.out stop_loop.cpp)
+
+target_link_libraries(tcpStream.out  PRIVATE ft_irc)

apps/server.cpp → apps/tcpAcceptor.cpp

@@ -55,6 +55,7 @@ int     main(int argc, char **argv)
         try{
             stream = server.accept();
             if (stream){
+                assert(stream->getPeerIP() == "127.0.0.1");
                 size_t          len;
                 char     buffer[256];
                 while ((len = stream->receive(buffer, sizeof(buffer))) > 0){
@@ -64,6 +65,8 @@ int     main(int argc, char **argv)
                 }
                 delete stream;
             }
+            else
+                assert(stream == NULL);
         }
         catch(std::exception &e){
             printException(e);

apps/client.cpp → apps/tcpConnector.cpp

@@ -41,6 +41,8 @@ void    basicTest(TcpConnector &connector, char **argv, std::string message){
     try{
         TcpStream* stream = connector.connect(atoi(argv[1]), argv[2]);
         if (stream) {
+            assert(stream->getPeerIP() == argv[2]);
+            assert(stream->getPeerPort() == atoi(argv[1]));
             send(message, *stream);
             receive(*stream);
             delete stream;

apps/tcpStream.cpp

@@ -0,0 +1,21 @@
+#include "TcpStream.hpp"
+
+#include <assert.h>
+#include <fcntl.h>
+#include <cstring>
+
+int main(void)
+{
+    struct sockaddr_in address;
+    memset(&address, 0, sizeof(address));
+
+    TcpStream stream(0, &address);
+
+    int nbSend = stream.send("Give a world of 6letters\n", 26);
+    assert(nbSend == 26);
+
+    char buffer[420];
+    int nbRec = stream.receive(buffer, sizeof(buffer));
+    assert(nbRec == 7);
+    return (0);
+}

src/tcp/TcpAcceptor.cpp

@@ -9,9 +9,9 @@ TcpAcceptor::~TcpAcceptor(){
         close(_mListenSd);
 }
 
-int         TcpAcceptor::init(){
+void         TcpAcceptor::init(){
     if (_mListening == true)
-        return 0;
+        return;
 
     createListenSocket();
 
@@ -20,12 +20,11 @@ int         TcpAcceptor::init(){
 
     setSocketOptions();
 
-    int result = bindSocket(&address);
+    bindSocket(&address);
 
-    result = setSocketListen();
+    setSocketListen();
 
     _mListening = true;
-    return result;
 }
 
 TcpStream*  TcpAcceptor::accept(){
@@ -45,6 +44,18 @@ int         TcpAcceptor::getListenSd() const{
     return _mListenSd;
 }
 
+std::string TcpAcceptor::getAddress() const{
+    return _mAddress;
+}
+
+int         TcpAcceptor::getPort() const{
+    return _mPort;
+}
+
+bool        TcpAcceptor::isListening() const {
+    return _mListening;
+}
+
 void        TcpAcceptor::createListenSocket(){
     _mListenSd = socket(AF_INET, SOCK_STREAM, 0);
 }
@@ -56,24 +67,22 @@ void        TcpAcceptor::inetSocketAddress(struct sockaddr_in *address){
     address->sin_addr.s_addr = inet_addr(_mAddress.c_str());
 }
 
-int         TcpAcceptor::bindSocket(struct sockaddr_in *address){
+void        TcpAcceptor::bindSocket(struct sockaddr_in *address){
     int result = bind(_mListenSd, (struct sockaddr*)address, sizeof(*address));
     if (result != 0)
         throw std::runtime_error("bind failed");
-    return result;
 }
 
-int         TcpAcceptor::setSocketListen(){
+void        TcpAcceptor::setSocketListen(){
     int result = listen(_mListenSd, 16);
     if (result != 0)
         throw std::runtime_error("listen failed");
-    return result;
 }
 
 void        TcpAcceptor::setSocketOptions(){
     //makes it possible to immidetly listen on same adddress and port when restart server
     int optval = 1;
-    setsockopt(_mListenSd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof optval);
+    setsockopt(_mListenSd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
 }
 
 std::ostream&           operator<<(std::ostream& o, TcpAcceptor const& src){

src/tcp/TcpAcceptor.hpp

@@ -5,15 +5,19 @@
 #include <cstring>
 #include <stdexcept>
 #include <iostream>
+#include <cassert>
 
 class TcpAcceptor{
     public:
         TcpAcceptor(int port, std::string address);
         ~TcpAcceptor();
 
-        int             init();
+        void            init();
         TcpStream*      accept();
         int             getListenSd() const;
+        int             getPort() const;
+        std::string     getAddress() const;
+        bool            isListening() const;
 
     private:
         int             _mListenSd;
@@ -25,9 +29,9 @@ class TcpAcceptor{
         TcpAcceptor();
 
         void            createListenSocket();
-        int             bindSocket(struct sockaddr_in *address);
+        void            bindSocket(struct sockaddr_in *address);
         void            inetSocketAddress(struct sockaddr_in *address);
-        int             setSocketListen();
+        void            setSocketListen();
         void            setSocketOptions();
 };
 

src/tcp/TcpStream.cpp

@@ -9,9 +9,7 @@ TcpStream::TcpStream(int sd, struct sockaddr_in* address){
 }
 
 TcpStream::TcpStream(const TcpStream& src){
-    _mPeerPort = src.getPeerPort();
-    _mPeerIP = src.getPeerIP();
-    _mSd = src._mSd;
+    *this = src;
 }
 
 TcpStream&      TcpStream::operator=(const TcpStream& src){

src/tcp/TcpStream.hpp

@@ -9,16 +9,6 @@
 
 class TcpStream
 {
-    public:
-        ~TcpStream();
-
-        ssize_t         send(std::string buffer, size_t len);
-        ssize_t         receive(char* buffer, size_t len);
-
-        std::string     getPeerIP() const;
-        int             getPeerPort() const;
-        int             getSd() const;
-
     private:
         int             _mSd;
         std::string     _mPeerIP;
@@ -28,11 +18,19 @@ class TcpStream
         TcpStream();
         TcpStream(int sd, struct sockaddr_in* address);
         TcpStream(const TcpStream& src);
+        ~TcpStream();
+
+        ssize_t         send(std::string buffer, size_t len);
+        ssize_t         receive(char* buffer, size_t len);
+
+        std::string     getPeerIP() const;
+        int             getPeerPort() const;
+        int             getSd() const;
 
-        TcpStream&      operator=(const TcpStream& src);
+        TcpStream&      operator = (const TcpStream& src);
 
 };
 
-std::ostream&       operator<<(std::ostream& o , TcpStream const & src);
+std::ostream&       operator << (std::ostream& o , TcpStream const & src);
 
 #endif

tests/tcp_acceptor.cpp

@@ -0,0 +1,48 @@
+#include <catch2/catch_all.hpp>
+#include "TcpAcceptor.hpp"
+
+TEST_CASE("Test constructor")
+{
+    TcpAcceptor acceptor(8080, "127.0.0.1");
+
+    REQUIRE(acceptor.getListenSd() == 0);
+    REQUIRE(acceptor.getPort() == 8080);
+    REQUIRE(acceptor.getAddress() == "127.0.0.1");
+}
+
+TEST_CASE("Test init"){
+    TcpAcceptor acceptor(8080, "127.0.0.1");
+
+    acceptor.init();
+
+    REQUIRE(acceptor.getListenSd() > 2);
+    REQUIRE(acceptor.isListening());    
+}
+
+TEST_CASE("Test listen"){
+    TcpAcceptor acceptor(8080, "127.0.0.1");
+    int val;
+    socklen_t length = sizeof(val);
+
+    acceptor.init();
+    getsockopt(acceptor.getListenSd(), SOL_SOCKET, SO_ACCEPTCONN, &val, &length);
+    REQUIRE(val);
+}
+
+TEST_CASE("Test bind"){
+    TcpAcceptor acceptor(8080, "127.0.0.1");
+
+    struct sockaddr_in address;
+    memset(&address, 0, sizeof(address));
+    socklen_t length = sizeof(address);
+
+    getsockname(acceptor.getListenSd(), (struct sockaddr*)&address, &length);
+    std::string adr = inet_ntoa(address.sin_addr);
+    REQUIRE(adr == "0.0.0.0");
+
+    acceptor.init();
+    int val = getsockname(acceptor.getListenSd(), (struct sockaddr*)&address, &length);
+    adr = inet_ntoa(address.sin_addr);
+    REQUIRE(val == 0);
+    REQUIRE(adr == "127.0.0.1");
+}

tests/tcp_stream.cpp

@@ -0,0 +1,25 @@
+#include <catch2/catch_all.hpp>
+#include "TcpStream.hpp"
+
+TEST_CASE("Test constructor")
+{
+    struct sockaddr_in address;
+    memset(&address, 0, sizeof(address));
+    TcpStream stream(5, &address);
+
+    REQUIRE(stream.getSd() == 5);
+    REQUIRE(stream.getPeerIP() == "0.0.0.0");
+    REQUIRE(stream.getPeerPort() == 0);
+}
+
+TEST_CASE("Test CopyConstructor")
+{
+    struct sockaddr_in address;
+    memset(&address, 0, sizeof(address));
+    TcpStream stream(5, &address);
+
+    TcpStream copy(stream);
+    REQUIRE(copy.getSd() == 5);
+    REQUIRE(copy.getPeerIP() == "0.0.0.0");
+    REQUIRE(copy.getPeerPort() == 0);
+}