Renamed UDP and TCP server classes

src/main.cpp

 #include <iostream>
 #include <QCoreApplication>
-#include "dns-server/QUdpDnsServer.h"
-#include "dns-server/QTcpDnsServer.h"
+#include "dns-server/QDnsUdpServer.h"
+#include "dns-server/QDnsTcpServer.h"
 #include "dns-base/QDnsBase.h"
 
 int main(int argc, char* argv[])
     QHostAddress bindAddress("127.0.0.1");
     quint16 bindPort = 5053;
 
-    auto onRequest = [](QDns::Server::QUdpDnsServer::OnRequestParams params)
+    auto onRequest = [](QDns::Server::QDnsUdpServer::OnRequestParams params)
     {
         QDns::Base::QDnsPacket answer = params.packet.makeAnswer();
         auto header = answer.getHeader();
                                   });
     };
 
-    QDns::Server::QTcpDnsServer tcpServer;
+    QDns::Server::QDnsTcpServer tcpServer;
     tcpServer.start(bindAddress, bindPort);
     QObject::connect(&tcpServer, &QDns::Server::QDnsServer::onRequest, onRequest);
 
-    QDns::Server::QUdpDnsServer udpServer;
+    QDns::Server::QDnsUdpServer udpServer;
     udpServer.start(bindAddress, bindPort);
     QObject::connect(&udpServer, &QDns::Server::QDnsServer::onRequest, onRequest);
 

src/modules/dns-server/CMakeLists.txt

 add_library(${PROJECT_NAME}
         src/QDnsServer.cpp
         includes/dns-server/QDnsServer.h
-        src/QUdpDnsServer.cpp
-        includes/dns-server/QUdpDnsServer.h
-        src/QTcpDnsServer.cpp
-        includes/dns-server/QTcpDnsServer.h
-        src/QTcpDnsServerClient.cpp
-        src/QTcpDnsServerClient.h)
+        src/QDnsUdpServer.cpp
+        includes/dns-server/QDnsUdpServer.h
+        src/QDnsTcpServer.cpp
+        includes/dns-server/QDnsTcpServer.h
+        src/QDnsTcpServerClient.cpp
+        src/QDnsTcpServerClient.h)
 
 target_link_libraries(${PROJECT_NAME} Qt5::Core Qt5::Network qdnsagg-dns-base)
 

src/modules/dns-server/includes/dns-server/QTcpDnsServer.h → src/modules/dns-server/includes/dns-server/QDnsTcpServer.h

 {
     namespace Server
     {
-        class QTcpDnsServerClient;
+        class QDnsTcpServerClient;
 
-        class QTcpDnsServer : public QDnsServer
+        class QDnsTcpServer : public QDnsServer
         {
             Q_OBJECT
         public:
-            QTcpDnsServer();
+            QDnsTcpServer();
 
         public slots:
             bool start(const QHostAddress& host, quint16 port) override;
         private:
             QTcpServer* m_socket;
 
-            QList<QTcpDnsServerClient*> m_clients;
+            QList<QDnsTcpServerClient*> m_clients;
         };
     }
 }

src/modules/dns-server/includes/dns-server/QUdpDnsServer.h → src/modules/dns-server/includes/dns-server/QDnsUdpServer.h

 {
     namespace Server
     {
-        class QUdpDnsServer : public QDnsServer
+        class QDnsUdpServer : public QDnsServer
         {
             Q_OBJECT
         public:
-            QUdpDnsServer();
+            QDnsUdpServer();
 
         public slots:
             bool start(const QHostAddress& host, quint16 port) override;

src/modules/dns-server/src/QTcpDnsServer.cpp → src/modules/dns-server/src/QDnsTcpServer.cpp

 //
 
 #include <QTcpSocket>
-#include "dns-server/QTcpDnsServer.h"
-#include "QTcpDnsServerClient.h"
+#include "dns-server/QDnsTcpServer.h"
+#include "QDnsTcpServerClient.h"
 
 namespace QDns
 {
     namespace Server
     {
-        QTcpDnsServer::QTcpDnsServer()
+        QDnsTcpServer::QDnsTcpServer()
             : m_socket(new QTcpServer(this))
         {
-            connect(m_socket, &QTcpServer::newConnection, this, &QTcpDnsServer::onNewConnection);
+            connect(m_socket, &QTcpServer::newConnection, this, &QDnsTcpServer::onNewConnection);
         }
 
-        bool QTcpDnsServer::start(const QHostAddress &host, quint16 port)
+        bool QDnsTcpServer::start(const QHostAddress &host, quint16 port)
         {
             return m_socket->listen(host, port);
         }
 
-        void QTcpDnsServer::onNewConnection()
+        void QDnsTcpServer::onNewConnection()
         {
             auto socket = m_socket->nextPendingConnection();
             if (socket == nullptr)
             {
                 return;
             }
-            auto client = new QTcpDnsServerClient(socket, this);
+            auto client = new QDnsTcpServerClient(socket, this);
             connect(socket, &QTcpSocket::disconnected, [client, this]()
             {
                 m_clients.removeOne(client);
                 client->deleteLater();
             });
-            connect(client, &QTcpDnsServerClient::onRequest, [this](QDnsServer::OnRequestParams params)
+            connect(client, &QDnsTcpServerClient::onRequest, [this](QDnsServer::OnRequestParams params)
             {
                 emit onRequest(params);
             });

src/modules/dns-server/src/QTcpDnsServerClient.cpp → src/modules/dns-server/src/QDnsTcpServerClient.cpp

 // Created by robin on 2/1/18.
 //
 
-#include "QTcpDnsServerClient.h"
+#include "QDnsTcpServerClient.h"
 
 namespace QDns
 {
     namespace Server
     {
-        QTcpDnsServerClient::QTcpDnsServerClient(QTcpSocket *socket, QObject* parent)
+        QDnsTcpServerClient::QDnsTcpServerClient(QTcpSocket *socket, QObject* parent)
             : QObject(parent)
             , m_socket(socket)
             , m_size(0)
         {
             m_socket->setParent(this);
-            connect(m_socket, &QTcpSocket::readyRead, this, &QTcpDnsServerClient::onReadyRead);
+            connect(m_socket, &QTcpSocket::readyRead, this, &QDnsTcpServerClient::onReadyRead);
             // TODO implement timeout (~2 mins, RFC 7766)
         }
 
-        void QTcpDnsServerClient::sendAnswer(const QDns::Server::QDnsServer::SendAnswerParams &answerParams)
+        void QDnsTcpServerClient::sendAnswer(const QDns::Server::QDnsServer::SendAnswerParams &answerParams)
         {
             auto answerRaw = answerParams.answer.serialize(); // TODO split packet if too big (>65535)
             QByteArray size;
             m_socket->write(answerRaw.constData(), answerRaw.size());
         }
 
-        void QTcpDnsServerClient::onReadyRead()
+        void QDnsTcpServerClient::onReadyRead()
         {
             m_buffer.append(m_socket->readAll());
 

src/modules/dns-server/src/QTcpDnsServerClient.h → src/modules/dns-server/src/QDnsTcpServerClient.h

 {
     namespace Server
     {
-        class QTcpDnsServerClient : public QObject
+        class QDnsTcpServerClient : public QObject
         {
             Q_OBJECT
         public:
-            explicit QTcpDnsServerClient(QTcpSocket* socket, QObject* parent = nullptr);
+            explicit QDnsTcpServerClient(QTcpSocket* socket, QObject* parent = nullptr);
 
         signals:
             void onRequest(QDnsServer::OnRequestParams params);

src/modules/dns-server/src/QUdpDnsServer.cpp → src/modules/dns-server/src/QDnsUdpServer.cpp

 // Created by robin on 1/24/18.
 //
 
-#include "dns-server/QUdpDnsServer.h"
+#include "dns-server/QDnsUdpServer.h"
 
 namespace QDns
 {
     namespace Server
     {
-        QUdpDnsServer::QUdpDnsServer()
+        QDnsUdpServer::QDnsUdpServer()
             : m_socket(new QUdpSocket(this))
         {
-            connect(m_socket, &QUdpSocket::readyRead, this, &QUdpDnsServer::onSocketReadyRead);
+            connect(m_socket, &QUdpSocket::readyRead, this, &QDnsUdpServer::onSocketReadyRead);
         }
 
-        bool QUdpDnsServer::start(const QHostAddress &host, quint16 port)
+        bool QDnsUdpServer::start(const QHostAddress &host, quint16 port)
         {
             return m_socket->bind(host, port);
         }
 
-        void QUdpDnsServer::onSocketReadyRead()
+        void QDnsUdpServer::onSocketReadyRead()
         {
             while (m_socket->hasPendingDatagrams())
             {
             }
         }
 
-        void QUdpDnsServer::sendAnswer(const QDns::Server::QDnsServer::SendAnswerParams& answerParams,
+        void QDnsUdpServer::sendAnswer(const QDns::Server::QDnsServer::SendAnswerParams& answerParams,
                                        const QHostAddress& senderAddress, quint16 senderPort)
         {
             auto answerRaw = answerParams.answer.serialize(); // TODO split packet if too big

src/modules/dns-server/tests/CMakeLists.txt

 add_executable(${PROJECT_NAME}
         main.cpp
         UdpDnsServer.cpp
-        TcpDnsServer.cpp
+        DnsTcpServer.cpp
         serverTests.h)
 
 target_link_libraries(${PROJECT_NAME} gtest pthread qdnsagg-dns-server)

src/modules/dns-server/tests/TcpDnsServer.cpp → src/modules/dns-server/tests/DnsTcpServer.cpp

 #include <QtCore/QTimer>
 #include <QtNetwork/QTcpSocket>
 
-#include "dns-server/QTcpDnsServer.h"
+#include "dns-server/QDnsTcpServer.h"
 
 #include "serverTests.h"
 
-struct TcpDnsServerTestParams
+struct DnsTcpServerTestParams
 {
     QList<const char*> hexData;
 };
 
-class TcpDnsServerTest : public ::testing::TestWithParam<TcpDnsServerTestParams>
+class DnsTcpServerTest : public ::testing::TestWithParam<DnsTcpServerTestParams>
 {
 };
 
-TEST_P(TcpDnsServerTest, simple)
+TEST_P(DnsTcpServerTest, simple)
 {
     auto params = GetParam();
     QCoreApplication app(m_argc, m_argv);
     QObject::connect(&timer, &QTimer::timeout, qApp, &QCoreApplication::quit);
     timer.start(1000);
 
-    QDns::Server::QTcpDnsServer server;
+    QDns::Server::QDnsTcpServer server;
     ASSERT_TRUE(server.start(QHostAddress("127.0.0.1"), 5053));
     QList<QDns::Base::QDnsPacket> packets;
     QObject::connect(&server, &QDns::Server::QDnsServer::onRequest, [&packets](QDns::Server::QDnsServer::OnRequestParams params)
     ASSERT_EQ(packets.size(), expectedPackets.size());
 }
 
-INSTANTIATE_TEST_CASE_P(TcpDnsServerTestInst,
-                        TcpDnsServerTest,
+INSTANTIATE_TEST_CASE_P(DnsTcpServerTestInst,
+                        DnsTcpServerTest,
                         ::testing::Values(
-                                TcpDnsServerTestParams
+                                DnsTcpServerTestParams
                                         {
                                                 QList<const char*>()
                                                         << "e1bc010000010000000000000266720000010001"

src/modules/dns-server/tests/UdpDnsServer.cpp

 #include <QtCore/QCoreApplication>
 #include <QtCore/QTimer>
 
-#include "dns-server/QUdpDnsServer.h"
+#include "dns-server/QDnsUdpServer.h"
 
 #include "serverTests.h"
 
-struct UdpDnsServerTestParams
+struct DnsUdpServerTestParams
 {
     QList<const char*> hexData;
 };
 
-class UdpDnsServerTest : public ::testing::TestWithParam<UdpDnsServerTestParams>
+class DnsUdpServerTest : public ::testing::TestWithParam<DnsUdpServerTestParams>
 {
 };
 
-TEST_P(UdpDnsServerTest, simple)
+TEST_P(DnsUdpServerTest, simple)
 {
     auto params = GetParam();
     QCoreApplication app(m_argc, m_argv);
     QObject::connect(&timer, &QTimer::timeout, qApp, &QCoreApplication::quit);
     timer.start(1000);
 
-    QDns::Server::QUdpDnsServer server;
+    QDns::Server::QDnsUdpServer server;
     ASSERT_TRUE(server.start(QHostAddress("127.0.0.1"), 5053));
     QList<QDns::Base::QDnsPacket> packets;
     QObject::connect(&server, &QDns::Server::QDnsServer::onRequest, [&packets](QDns::Server::QDnsServer::OnRequestParams params)
     ASSERT_EQ(packets.size(), expectedPackets.size());
 }
 
-INSTANTIATE_TEST_CASE_P(UdpDnsServerTestInst,
-                        UdpDnsServerTest,
+INSTANTIATE_TEST_CASE_P(DnsUdpServerTestInst,
+                        DnsUdpServerTest,
                         ::testing::Values(
-                                UdpDnsServerTestParams
+                                DnsUdpServerTestParams
                                         {
                                                 QList<const char*>()
                                                         << "e1bc010000010000000000000266720000010001"