Davidenko 08 timer

tdd_intro/3rd_party/gtest/googletest/include/gtest/internal/gtest-internal.h

@@ -65,6 +65,12 @@
 #include "gtest/internal/gtest-filepath.h"
 #include "gtest/internal/gtest-type-util.h"
 
+
+enum RelationToSource {
+  kReference,  // The NativeArray references the native array.
+  kCopy           // The NativeArray makes a copy of the native array and
+                      // owns the copy.
+};
 // Due to C++ preprocessor weirdness, we need double indirection to
 // concatenate two tokens when one of them is __LINE__.  Writing
 //

tdd_intro/cleanroom/chatclient/chatclient.pro

@@ -6,9 +6,13 @@ CONFIG -= app_bundle
 CONFIG -= qt
 
 SOURCES += \
-    test.cpp
+    test.cpp \
+    socketwrapper.cpp
 
 LIBS += \
     Ws2_32.lib \
     Mswsock.lib \
     AdvApi32.lib
+
+HEADERS += \
+    socketwrapper.h

tdd_intro/cleanroom/chatclient/socketwrapper.cpp

@@ -0,0 +1,107 @@
+#define WIN32_LEAN_AND_MEAN
+#define _WINSOCK_DEPRECATED_NO_WARNINGS
+
+#include <windows.h>
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <exception>
+#include <vector>
+#include <string>
+#include <sstream>
+#include <memory>
+
+#include "SocketWrapper.h"
+
+namespace
+{
+    std::string GetExceptionString(const std::string& message, int errorCode)
+    {
+        std::stringstream stream;
+        stream << message;
+        stream << errorCode;
+        stream << std::endl;
+        return stream.str();
+    }
+}
+
+SocketWrapper::SocketWrapper()
+    : m_socket(INVALID_SOCKET)
+{
+    m_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    if (m_socket == INVALID_SOCKET)
+    {
+        throw std::runtime_error(GetExceptionString("Failed to create socket to listen on.", WSAGetLastError()));
+    }
+}
+
+SocketWrapper::SocketWrapper(SOCKET & other)
+    : m_socket(other)
+{
+}
+
+SocketWrapper::~SocketWrapper()
+{
+    closesocket(m_socket);
+}
+
+void SocketWrapper::Bind(const std::string& addr, int16_t port)
+{
+    sockaddr_in addres;
+    addres.sin_family = AF_INET;
+    addres.sin_addr.s_addr = inet_addr(addr.data());
+    addres.sin_port = htons(port);
+    if (bind(m_socket, reinterpret_cast<sockaddr*>(&addres), sizeof(addres)) == SOCKET_ERROR)
+    {
+        throw std::runtime_error(GetExceptionString("Failed to bind socket to address.", WSAGetLastError()));
+    }
+}
+
+void SocketWrapper::Listen()
+{
+    if (listen(m_socket, SOMAXCONN) == SOCKET_ERROR)
+    {
+        throw std::runtime_error(GetExceptionString("Failed to listen on socket.", WSAGetLastError()));
+    }
+}
+
+ISocketWrapperPtr SocketWrapper::Accept()
+{
+//    SOCKET other = accept(m_socket, nullptr, nullptr);
+//    if (other == INVALID_SOCKET)
+//    {
+//        throw std::runtime_error(GetExceptionString("Failed to connect to client.", WSAGetLastError()));
+//    }
+//    return SocketWrapper(other);
+    return nullptr;
+}
+
+ISocketWrapperPtr SocketWrapper::Connect(const std::string& addr, int16_t port)
+{
+//    sockaddr_in addres;
+//    addres.sin_family = AF_INET;
+//    addres.sin_addr.s_addr = inet_addr(addr.data());
+//    addres.sin_port = htons(port);
+//    SOCKET other = connect(m_socket, reinterpret_cast<sockaddr*>(&addres), sizeof(addres));
+//    if (other == INVALID_SOCKET)
+//    {
+//        throw std::runtime_error(GetExceptionString("Failed to connect to server.", WSAGetLastError()));
+//    }
+//    return SocketWrapper(other);
+    return nullptr;
+}
+
+void SocketWrapper::Read(std::string& buffer)
+{
+    std::vector<char> bufferTmp;
+    bufferTmp.resize(buffer.size());
+    if (SOCKET_ERROR == recv(m_socket, bufferTmp.data(), bufferTmp.size(), 0))
+    {
+        throw std::runtime_error(GetExceptionString("Failed to connect to server.", WSAGetLastError()));
+    }
+    buffer.assign(bufferTmp.begin(), bufferTmp.end());
+}
+
+void SocketWrapper::Write(const std::string& buffer)
+{
+    send(m_socket, buffer.data(), buffer.size(), 0);
+}

tdd_intro/cleanroom/chatclient/socketwrapper.h

@@ -0,0 +1,35 @@
+#pragma once
+#include <cstdint>
+#include <windows.h>
+#include <memory>
+
+class ISocketWrapper;
+using ISocketWrapperPtr = std::shared_ptr<ISocketWrapper>;
+
+class ISocketWrapper
+{
+public:
+    virtual void Bind(const std::string& addr, int16_t port) = 0;
+    virtual void Listen()= 0;
+    virtual ISocketWrapperPtr Accept() = 0;
+    virtual ISocketWrapperPtr Connect(const std::string& addr, int16_t port)= 0;
+    virtual void Read(std::string& buffer)= 0;
+    virtual void Write(const std::string& buffer)= 0;
+};
+
+class SocketWrapper : public ISocketWrapper
+{
+public:
+    SocketWrapper();
+    explicit SocketWrapper(SOCKET& other);
+    ~SocketWrapper();
+    void Bind(const std::string& addr, int16_t port);
+    void Listen();
+    ISocketWrapperPtr Accept();
+    ISocketWrapperPtr Connect(const std::string& addr, int16_t port);
+    void Read(std::string& buffer);
+    void Write(const std::string& buffer);
+
+private:
+    SOCKET m_socket;
+};

tdd_intro/cleanroom/chatclient/test.cpp

@@ -1,5 +1,6 @@
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
+#include "socketwrapper.h"
 
 using namespace testing;
 /*
@@ -38,3 +39,83 @@ Implement chat application, that communicates via TCP sockets.
     * If user enters '!exit!' message, application must close connection and exit
     * If user runs app with 'me' nickname - error with text "Username me is reserved and can not be used"  is displayed and application exits
 */
+
+class MockSocketWrapper : public ISocketWrapper
+{
+public:
+    MOCK_METHOD2(Bind, void(const std::string& addr, int16_t port));
+    MOCK_METHOD0(Listen, void());
+    MOCK_METHOD0(Accept, ISocketWrapperPtr());
+    MOCK_METHOD2(Connect, ISocketWrapperPtr(const std::string& addr, int16_t port));
+    MOCK_METHOD1(Read, void(std::string& buffer));
+    MOCK_METHOD1(Write, void(const std::string& buffer));
+
+};
+
+class Channel
+{
+public:
+    explicit Channel(ISocketWrapper& wrapper): m_wrapper(wrapper)  {}
+    void Send(const std::string& message) { m_wrapper.Write(message);}
+    void Receive(std::string& message) { m_wrapper.Read(message);}
+
+private:
+    ISocketWrapper& m_wrapper;
+};
+
+void ClientHandshake(Channel& channel, const std::string& login)
+{
+    std::string buffer;
+    channel.Send(login + ":HELLO");
+    channel.Receive(buffer);
+
+}
+
+void ServerHandshake(Channel& channel, const std::string& login)
+{
+    std::string buffer;
+    channel.Receive(buffer);
+    channel.Send(login + ":HELLO!");
+}
+
+TEST(SocketWrapperTest, Sending)
+{
+    MockSocketWrapper socket;
+    Channel channel(socket);
+
+    EXPECT_CALL(socket, Write("Hello")).Times(1);
+    channel.Send("Hello");
+}
+
+TEST(SocketWrapperTest, Receiving)
+{
+    MockSocketWrapper socket;
+    Channel channel(socket);
+
+    std::string buffer;
+    EXPECT_CALL(socket, Read(_)).WillOnce(SetArgReferee<0>("Hello"));
+    channel.Receive(buffer);
+
+    EXPECT_EQ("Hello", buffer);
+}
+
+TEST(SocketWrapperTest, ClientHandshake)
+{
+    MockSocketWrapper socket;
+    Channel channel(socket);
+    InSequence sequence;
+    EXPECT_CALL(socket, Write("metizik:HELLO")).Times(1);
+    EXPECT_CALL(socket, Read(_)).Times(1);
+    ClientHandshake(channel, "metizik");
+}
+
+TEST(SocketWrapperTest, ServerHandshake)
+{
+    MockSocketWrapper socket;
+    Channel channel(socket);
+    EXPECT_CALL(socket, Read(_)).Times(1);
+    EXPECT_CALL(socket, Write("user:HELLO!")).Times(1);
+    ServerHandshake(channel, "user");
+}
+
+