diff --git a/common/cpp/include/system_wrappers/io.h b/common/cpp/include/system_wrappers/io.h
index f2a781a6929f4fdb66a129517a53367dd0cfa161..cb72c12881ff7b968c55021e33d481420b02555b 100644
--- a/common/cpp/include/system_wrappers/io.h
+++ b/common/cpp/include/system_wrappers/io.h
@@ -45,53 +45,34 @@ typedef int FileDescriptor;
 
 class IO {
   public:
-
-    virtual FileData GetDataFromFile(const std::string &fname, IOErrors* err) = 0;
-
-
     /*
      * Network
      */
     virtual FileDescriptor  create_socket   (AddressFamilies address_family, SocketTypes socket_type, SocketProtocols socket_protocol, IOErrors* err) = 0;
     virtual void            listen          (FileDescriptor socket_fd, int backlog, IOErrors* err) = 0;
     virtual void            inet_bind       (FileDescriptor socket_fd, const std::string& address, uint16_t port, IOErrors* err) = 0;
-    virtual std::unique_ptr<std::tuple<std::string, hidra2::FileDescriptor>> inet_accept(FileDescriptor socket_fd, IOErrors* err) = 0;
-    virtual void            inet_connect    (FileDescriptor socket_fd, const std::string& address, hidra2::IOErrors* err) = 0;
-    virtual FileDescriptor  create_and_connect_ip_tcp_socket(const std::string& address, hidra2::IOErrors* err) = 0;
-
-    virtual size_t          receive         (FileDescriptor socket_fd, void* buf, size_t length, hidra2::IOErrors* err) = 0;
-    virtual void receive_timeout(FileDescriptor socket_fd,
-                                 void* buf,
-                                 size_t length,
-                                 uint16_t timeout_in_sec,
-                                 hidra2::IOErrors* err) = 0;
-    virtual size_t          send            (FileDescriptor socket_fd, const void* buf, size_t length, hidra2::IOErrors* err) = 0;
+    virtual std::unique_ptr<std::tuple<std::string, FileDescriptor>> inet_accept(FileDescriptor socket_fd, IOErrors* err) = 0;
+    virtual void            inet_connect    (FileDescriptor socket_fd, const std::string& address, IOErrors* err) = 0;
+    virtual FileDescriptor  create_and_connect_ip_tcp_socket(const std::string& address, IOErrors* err) = 0;
+
+    virtual size_t          receive         (FileDescriptor socket_fd, void* buf, size_t length, IOErrors* err) = 0;
+    virtual size_t          receive_timeout (FileDescriptor socket_fd,
+                                             void* buf,
+                                             size_t length,
+                                             uint16_t timeout_in_sec,
+                                             IOErrors* err) = 0;
+    virtual size_t          send            (FileDescriptor socket_fd, const void* buf, size_t length, IOErrors* err) = 0;
 
     /*
      * Generic
      */
-    virtual int deprecated_open(const char* __file, int __oflag) = 0;
-    virtual int deprecated_close(int __fd) = 0;
-    virtual ssize_t deprecated_read(int __fd, void* buf, size_t count) = 0;
-    virtual ssize_t deprecated_write(int __fd, const void* __buf, size_t __n) = 0;
-
-    /**
-     * Network - legacy
-     **/
-    virtual int     deprecated_socket(int __domain, int __type, int __protocol) = 0;
-    virtual int     deprecated_bind(int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len) = 0;
-    virtual int     deprecated_listen(int __fd, int __n) = 0;
-    virtual int     deprecated_accept(int __fd, __SOCKADDR_ARG __addr, socklen_t* __restrict __addr_len) = 0;
-    virtual int     deprecated_connect(int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len) = 0;
-    virtual ssize_t deprecated_recv(int __fd, void* __buf, size_t __n, int __flags) = 0;
-    virtual ssize_t deprecated_send(int __fd, const void* __buf, size_t __n, int __flags) = 0;
-    virtual int     deprecated_select(int __nfds,
-                                      fd_set* __readfds,
-                                      fd_set* __writefds,
-                                      fd_set* __exceptfds,
-                                      struct timeval* __timeout) = 0;
-
-// this is not standard function - to be implemented differently in windows and linux
+    virtual int deprecated_open             (const char* __file, int __oflag) = 0;
+    virtual int deprecated_close            (int __fd) = 0;
+    virtual ssize_t deprecated_read         (int __fd, void* buf, size_t count) = 0;
+    virtual ssize_t deprecated_write        (int __fd, const void* __buf, size_t __n) = 0;
+
+    // this is not standard function - to be implemented differently in windows and linux
+    virtual FileData GetDataFromFile        (const std::string &fname, IOErrors* err) = 0;
     virtual std::vector<FileInfo> FilesInFolder(const std::string& folder, IOErrors* err) = 0;
 };
 
diff --git a/common/cpp/include/system_wrappers/system_io.h b/common/cpp/include/system_wrappers/system_io.h
index 1b1bf123846522b9cc0b737c8c74781fc707aaf2..ac944b26e09984849a8ef7e71ef71fee6adbbd90 100644
--- a/common/cpp/include/system_wrappers/system_io.h
+++ b/common/cpp/include/system_wrappers/system_io.h
@@ -8,58 +8,35 @@ namespace hidra2 {
 
 class SystemIO final : public IO {
   public:
-    /**
+    /*
      * Network
-     **/
+     */
     FileDescriptor  create_socket   (AddressFamilies address_family, SocketTypes socket_type, SocketProtocols socket_protocol, IOErrors* err);
-    void            inet_bind(FileDescriptor socket_fd,
-                              const std::string& address,
-                              uint16_t port,
-                              IOErrors* err);
     void            listen          (FileDescriptor socket_fd, int backlog, IOErrors* err);
-    std::unique_ptr<std::tuple<std::string, hidra2::FileDescriptor>> inet_accept(FileDescriptor socket_fd,
-                                                                                 IOErrors* err);
-    void            inet_connect(FileDescriptor socket_fd, const std::string& address, hidra2::IOErrors* err);
+    void            inet_bind       (FileDescriptor socket_fd, const std::string& address, uint16_t port, IOErrors* err);
+    std::unique_ptr<std::tuple<std::string, FileDescriptor>> inet_accept(FileDescriptor socket_fd, IOErrors* err);
+    void            inet_connect    (FileDescriptor socket_fd, const std::string& address, IOErrors* err);
+    FileDescriptor  create_and_connect_ip_tcp_socket(const std::string& address, IOErrors* err);
 
-
-    FileDescriptor  create_and_connect_ip_tcp_socket(const std::string& address, hidra2::IOErrors* err);
-
-
-    size_t          receive         (FileDescriptor socket_fd, void* buf, size_t length, hidra2::IOErrors* err);
-    void receive_timeout            (FileDescriptor socket_fd,
+    size_t          receive         (FileDescriptor socket_fd, void* buf, size_t length, IOErrors* err);
+    size_t          receive_timeout (FileDescriptor socket_fd,
                                      void* buf,
                                      size_t length,
                                      uint16_t timeout_in_sec,
-                                     hidra2::IOErrors* err);
-    size_t          send            (FileDescriptor socket_fd, const void* buf, size_t length, hidra2::IOErrors* err);
+                                     IOErrors* err);
+    size_t          send            (FileDescriptor socket_fd, const void* buf, size_t length, IOErrors* err);
 
-    /**
+    /*
      * Generic
-     **/
-    FileData GetDataFromFile(const std::string &fname, IOErrors* err);
-    int deprecated_open(const char* __file, int __oflag);
-    int deprecated_close(int __fd);
-    ssize_t deprecated_read(int __fd, void* buf, size_t count);
-    ssize_t deprecated_write(int __fd, const void* __buf, size_t __n);
-    
+     */
+    int deprecated_open             (const char* __file, int __oflag);
+    int deprecated_close            (int __fd);
+    ssize_t deprecated_read         (int __fd, void* buf, size_t count);
+    ssize_t deprecated_write        (int __fd, const void* __buf, size_t __n);
+
+    // this is not standard function - to be implemented differently in windows and linux
+    FileData GetDataFromFile        (const std::string &fname, IOErrors* err);
     std::vector<FileInfo> FilesInFolder(const std::string& folder, IOErrors* err);
-
-    /**
-     * Network - legacy
-     **/
-    int     deprecated_socket(int __domain, int __type, int __protocol);
-    int     deprecated_bind(int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len);
-    int     deprecated_listen(int __fd, int __n);
-    int     deprecated_accept(int __fd, __SOCKADDR_ARG __addr, socklen_t* __restrict __addr_len);
-    int     deprecated_connect(int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len);
-    ssize_t deprecated_recv(int __fd, void* __buf, size_t __n, int __flags);
-    ssize_t deprecated_send(int __fd, const void* __buf, size_t __n, int __flags);
-    int     deprecated_select(int __nfds,
-                              fd_set* __readfds,
-                              fd_set* __writefds,
-                              fd_set* __exceptfds,
-                              struct timeval* __timeout);
-
 };
 }
 
diff --git a/common/cpp/src/system_io.cpp b/common/cpp/src/system_io.cpp
index cb2ecfe411637a61ecdd45595854b5681193c090..782f65a3ea91def64468aa5aaf623f4cdfd6743f 100644
--- a/common/cpp/src/system_io.cpp
+++ b/common/cpp/src/system_io.cpp
@@ -18,41 +18,3 @@ ssize_t hidra2::SystemIO::deprecated_read(int __fd, void* buf, size_t count) {
 ssize_t hidra2::SystemIO::deprecated_write(int __fd, const void* __buf, size_t __n) {
     return ::write(__fd, __buf, __n);
 }
-
-int hidra2::SystemIO::deprecated_socket(int __domain, int __type, int __protocol) {
-    return ::socket(__domain, __type, __protocol);
-}
-
-int hidra2::SystemIO::deprecated_bind(int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len) {
-    return ::bind(__fd, __addr, __len);
-}
-
-int hidra2::SystemIO::deprecated_listen(int __fd, int __n) {
-  return ::listen(__fd, __n);
-}
-
-int hidra2::SystemIO::deprecated_accept(int __fd, __SOCKADDR_ARG __addr, socklen_t* __restrict __addr_len) {
-  return ::accept(__fd, __addr, __addr_len);
-}
-
-ssize_t hidra2::SystemIO::deprecated_recv(int __fd, void* __buf, size_t __n, int __flags) {
-    return ::recv(__fd, __buf, __n, __flags);
-}
-
-ssize_t hidra2::SystemIO::deprecated_send(int __fd, const void* __buf, size_t __n, int __flags) {
-    return ::send(__fd, __buf, __n, __flags);
-}
-
-int hidra2::SystemIO::deprecated_connect(int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len) {
-    return ::connect(__fd, __addr, __len);
-}
-
-int hidra2::SystemIO::deprecated_select(int __nfds,
-                                        fd_set* __readfds,
-                                        fd_set* __writefds,
-                                        fd_set* __exceptfds,
-                                        struct timeval* __timeout) {
-    return ::select(__nfds, __readfds, __writefds, __exceptfds, __timeout);
-}
-
-
diff --git a/common/cpp/src/system_io_linux.cpp b/common/cpp/src/system_io_linux.cpp
index 99e592a7d8b9338027e22431c96fae079de4a19b..705de99fe41f307134cece3b3c3c54c68d203218 100644
--- a/common/cpp/src/system_io_linux.cpp
+++ b/common/cpp/src/system_io_linux.cpp
@@ -329,7 +329,7 @@ size_t hidra2::SystemIO::receive(hidra2::FileDescriptor socket_fd, void* buf, si
     return already_received;
 }
 
-void hidra2::SystemIO::receive_timeout(hidra2::FileDescriptor socket_fd,
+size_t hidra2::SystemIO::receive_timeout(hidra2::FileDescriptor socket_fd,
                                        void* buf,
                                        size_t length,
                                        uint16_t timeout_in_sec,
@@ -345,14 +345,14 @@ void hidra2::SystemIO::receive_timeout(hidra2::FileDescriptor socket_fd,
     int res = select(socket_fd+1, &read_fds, nullptr, nullptr, &timeout);
     if(res == 0) {
         *err = IOErrors::TIMEOUT;
-        return;
+        return 0;
     }
     if(res == -1) {
         *err = IOErrorFromErrno();
-        return;
+        return 0;
     }
 
-    receive(socket_fd, buf, length, err);
+    return receive(socket_fd, buf, length, err);
 }
 
 size_t hidra2::SystemIO::send(hidra2::FileDescriptor socket_fd,
diff --git a/producer/api/src/producer_impl.cpp b/producer/api/src/producer_impl.cpp
index 4a4c9951f3d3b577c177ec7c7f01e5c2fa6e9860..19a853ead40709495a6e59fdb7327bc94115d10c 100644
--- a/producer/api/src/producer_impl.cpp
+++ b/producer/api/src/producer_impl.cpp
@@ -79,7 +79,7 @@ hidra2::ProducerError hidra2::ProducerImpl::connect_to_receiver(const std::strin
         return PRODUCER_ERROR__OK;
     }
 
-    std::cerr << "Fail to deprecated_connect to server. NetErrorCode: " << helloResponse.error_code << std::endl;
+    std::cerr << "Fail to connect to server. NetErrorCode: " << helloResponse.error_code << std::endl;
 
     return PRODUCER_ERROR__OK;
 }
@@ -118,14 +118,10 @@ hidra2::ProducerError hidra2::ProducerImpl::send(std::string filename, void *dat
     std::cout << "error_code: " << prepareSendDataResponse.error_code << std::endl;
     std::cout << "file_reference_id: " << prepareSendDataResponse.file_reference_id << std::endl;
 
-
     NetworkErrorCode network_error = NET_ERR__NO_ERROR;
     size_t already_send = 0;
     uint64_t max_chunk_size = (uint64_t)1024*(uint64_t)1024*(uint64_t)1024*(uint64_t)2;
 
-
-    int fd = ::open("/home/cpatzke/Desktop/bigfile", O_RDONLY);
-
     while(!network_error && already_send < file_size) {
         size_t need_to_send = max_chunk_size;
 
diff --git a/producer/api/unittests/test_producer_impl.cpp b/producer/api/unittests/test_producer_impl.cpp
index e6f2a91e29190331795c2f04d787eaa68121b927..0e769a804829aa26770d2560a7b5d33c56bf97c4 100644
--- a/producer/api/unittests/test_producer_impl.cpp
+++ b/producer/api/unittests/test_producer_impl.cpp
@@ -3,88 +3,79 @@
 #include <netinet/in.h>
 #include "../src/producer_impl.h"
 
-namespace hidra2 {
+namespace {
 
 using ::testing::Return;
+using ::testing::_;
+using ::testing::DoAll;
+using ::testing::SetArgReferee;
+//using ::testing::SetArg;
+using ::testing::Gt;
 
-class MockIO : public IO {
+class MockIO : public hidra2::IO {
  public:
-    MOCK_METHOD2(GetDataFromFile,
-                 FileData(const std::string &fname, IOErrors* err));
+    MOCK_METHOD4(create_socket,
+                 hidra2::FileDescriptor(hidra2::AddressFamilies address_family, hidra2::SocketTypes socket_type, hidra2::SocketProtocols socket_protocol, hidra2::IOErrors* err));
+    MOCK_METHOD3(listen,
+                 void(hidra2::FileDescriptor socket_fd, int backlog, hidra2::IOErrors* err));
+    MOCK_METHOD4(inet_bind,
+                 void(hidra2::FileDescriptor socket_fd, const std::string& address, uint16_t port, hidra2::IOErrors* err));
+    MOCK_METHOD2(inet_accept,
+                 std::unique_ptr<std::tuple<std::string, hidra2::FileDescriptor>>(hidra2::FileDescriptor socket_fd, hidra2::IOErrors* err));
+    MOCK_METHOD3(inet_connect,
+                 void(hidra2::FileDescriptor socket_fd, const std::string& address, hidra2::IOErrors* err));
+    MOCK_METHOD2(create_and_connect_ip_tcp_socket,
+                 hidra2::FileDescriptor(const std::string& address, hidra2::IOErrors* err));
+    MOCK_METHOD4(receive,
+                 size_t(hidra2::FileDescriptor socket_fd, void* buf, size_t length, hidra2::IOErrors* err));
+    MOCK_METHOD5(receive_timeout,
+                 size_t(hidra2::FileDescriptor socket_fd, void* buf, size_t length, uint16_t timeout_in_sec, hidra2::IOErrors* err));
+    MOCK_METHOD4(send,
+                 size_t(hidra2::FileDescriptor socket_fd, const void* buf, size_t length, hidra2::IOErrors* err));
     MOCK_METHOD2(deprecated_open,
-                 int(
-                     const char* __file,
-                     int __oflag));
+                 int(const char* __file, int __oflag));
     MOCK_METHOD1(deprecated_close,
-                 int(int
-                     __fd));
+                 int(int __fd));
     MOCK_METHOD3(deprecated_read,
-                 ssize_t(int
-                     __fd, void * buf, size_t
-                     count));
+                 ssize_t(int __fd, void* buf, size_t count));
     MOCK_METHOD3(deprecated_write,
-                 ssize_t(int
-                     __fd,
-                     const void* __buf, size_t
-                     __n));
-    MOCK_METHOD3(deprecated_socket,
-                 int(int
-                     __domain, int
-                     __type, int
-                     __protocol));
-    MOCK_METHOD3(deprecated_bind,
-                 int(int
-                     __fd, __CONST_SOCKADDR_ARG
-                     __addr, socklen_t
-                     __len));
-    MOCK_METHOD2(deprecated_listen,
-                 int(int
-                     __fd, int
-                     __n));
-    MOCK_METHOD3(deprecated_accept,
-                 int(int
-                     __fd, __SOCKADDR_ARG
-                     __addr, socklen_t *
-                     __restrict __addr_len));
-    MOCK_METHOD3(deprecated_connect,
-                 int(int
-                     __fd, __CONST_SOCKADDR_ARG
-                     __addr, socklen_t
-                     __len));
-    MOCK_METHOD4(deprecated_recv,
-                 ssize_t(int
-                     __fd, void * __buf, size_t
-                     __n, int
-                     __flags));
-    MOCK_METHOD4(deprecated_send,
-                 ssize_t(int
-                     __fd,
-                     const void* __buf, size_t
-                     __n, int
-                     __flags));
-    MOCK_METHOD5(deprecated_select,
-                 int(int
-                     __nfds, fd_set * __readfds, fd_set * __writefds, fd_set * __exceptfds,
-                     struct timeval* __timeout));
+                 ssize_t(int __fd, const void* __buf, size_t __n));
+    MOCK_METHOD2(GetDataFromFile,
+                 hidra2::FileData(const std::string &fname, hidra2::IOErrors* err));
     MOCK_METHOD2(FilesInFolder,
-                 std::vector<FileInfo>(const std::string& folder, IOErrors* err));
+                 std::vector<hidra2::FileInfo>(const std::string& folder, hidra2::IOErrors* err));
 };
 
-
 TEST(get_version, VersionAboveZero) {
     hidra2::ProducerImpl producer;
     EXPECT_GE(producer.get_version(), 0);
 }
 
 
-TEST(connect_to_receiver, blatodo) {
+ACTION(write_hello_reponse_arg1) {
+    ((hidra2::HelloResponse*)arg1)->error_code = hidra2::NET_ERR__NO_ERROR;
+}
+
+TEST(ProducerImpl, connect_to_receiver) {
     MockIO mockIO;
 
     hidra2::ProducerImpl producer;
     producer.__set_io(&mockIO);
 
-    EXPECT_CALL(mockIO, socket(AF_INET, 0, IPPROTO_IP)).WillOnce(Return(-1));
+    std::string expected_address = "127.0.0.1:9090";
+    int         expected_fd = 83942;
+
+    EXPECT_CALL(mockIO, create_and_connect_ip_tcp_socket(expected_address, _))
+        .WillOnce(DoAll(testing::SetArgPointee<1>(hidra2::IOErrors::NO_ERROR), Return(expected_fd)));
+
+    EXPECT_CALL(mockIO, send(expected_fd, _/*addr*/, sizeof(hidra2::HelloRequest), _))
+        .WillOnce(DoAll(testing::SetArgPointee<3>(hidra2::IOErrors::NO_ERROR), Return(sizeof(hidra2::HelloRequest))));
+
+
+
+    EXPECT_CALL(mockIO, receive_timeout(expected_fd, _/*addr*/, sizeof(hidra2::HelloResponse), Gt(0), _))
+        .WillOnce(DoAll(write_hello_reponse_arg1(), testing::SetArgPointee<4>(hidra2::IOErrors::NO_ERROR), Return(sizeof(hidra2::HelloResponse))));
 
-    producer.connect_to_receiver("127.0.0.1");
+    EXPECT_EQ(producer.connect_to_receiver(expected_address), hidra2::PRODUCER_ERROR__OK);
 }
 }