tests for basic connection, handshake errors, timeout

libptsocket/ptsocket.cpp

@@ -3,9 +3,15 @@
 
 PTSocket::PTSocket(QObject* p) : QTcpSocket(p)
 {
+#ifdef PT_DEBUG
+    m_willPing = true;
+    dbgSetWillHandshake(true);
+#endif
     setSocketOption(QAbstractSocket::LowDelayOption, 1);
     m_packetSize = 0;
+    m_timeoutTimer.setSingleShot(true);
     setTimeout(5000);
+    m_pingTimer.setSingleShot(true);
     setPingInterval(1000 * 7);
     m_state = Disconnected;
     m_isServerSide = false;
@@ -31,6 +37,11 @@ bool PTSocket::isServerSide() const
     return m_isServerSide;
 }
 
+QString PTSocket::getError() const
+{
+    return (m_error.isEmpty()? errorString() : m_error);
+}
+
 QByteArray PTSocket::handshakeData()
 {
     return "LibPTSocketv1";
@@ -64,6 +75,51 @@ void PTSocket::send(int pktType, QByteArray data)
     send(false, pktType, data);
 }
 
+void PTSocket::disconnectFromServer()
+{
+    disconnectFromHost();
+}
+
+void PTSocket::dbgSetWillPing(bool w)
+{
+#ifdef PT_DEBUG
+    m_willPing = w;
+#endif
+}
+
+void PTSocket::dbgSetWillHandshake(bool w)
+{
+#ifdef PT_DEBUG
+    m_willHandshake = w;
+    m_willHandshakeFake1 = false;
+    m_willHandshakeFake2 = false;
+#endif
+}
+
+void PTSocket::dbgSetWillHandshakeFake1(bool w)
+{
+#ifdef PT_DEBUG
+    m_willHandshakeFake1 = w;
+    if(!w)
+        m_willHandshake = true;
+    else
+        m_willHandshake = false;
+    m_willHandshakeFake2 = false;
+#endif
+}
+
+void PTSocket::dbgSetWillHandshakeFake2(bool w)
+{
+#ifdef PT_DEBUG
+    m_willHandshakeFake2 = w;
+    if(!w)
+        m_willHandshake = true;
+    else
+        m_willHandshake = false;
+    m_willHandshakeFake1 = false;
+#endif
+}
+
 void PTSocket::send(bool sys, int pktType, QByteArray data)
 {
     if(data.isEmpty())
@@ -79,7 +135,13 @@ void PTSocket::m_ping()
     m_pingTimer.stop();
     if(m_timeoutTimer.isActive())
         return;
+
+#ifdef PT_DEBUG
+    if(m_willPing)
+        send(true, PingRequest);
+#else
     send(true, PingRequest);
+#endif
     m_timeoutTimer.start();
 }
 
@@ -107,7 +169,14 @@ void PTSocket::m_readyRead()
                 if(sys)
                 {
                     if(pktType == PingRequest)
+                    {
+#ifdef PT_DEBUG
+                        if(m_willPing)
+                            send(true, PingAnswer);
+#else
                         send(true, PingAnswer);
+#endif
+                    }
                     //else if(pktType == PingAnswer)
                 }
                 else
@@ -169,7 +238,16 @@ void PTSocket::m_stateChanged(QAbstractSocket::SocketState s)
     {
         m_packetSize = 0;
         setState(Connected);
+#ifdef PT_DEBUG
+        if(m_willHandshakeFake1)
+            write("LibPTSocketv");
+        else if(m_willHandshakeFake2)
+            write("42LibPTSocketv4242");
+        else if(m_willHandshake)
+            write(handshakeData());
+#else
         write(handshakeData());
+#endif
     }
     else if(s == QAbstractSocket::ClosingState)
         setState(Disconnecting);
@@ -181,32 +259,43 @@ void PTSocket::m_stateChanged(QAbstractSocket::SocketState s)
     }
 }
 
-void PTSocket::m_socketError(QAbstractSocket::SocketError)
+void PTSocket::m_socketError(QAbstractSocket::SocketError s)
 {
-    setState(Error);
+    if(s != QAbstractSocket::RemoteHostClosedError)
+    {
+        qDebug()<<"Socket error:"<<s;
+        setState(Error);
+    }
 }
 
 void PTSocket::setState(PTSocket::State s)
 {
-    if(s == m_state || (s == Error && (m_state == Disconnected || m_state == Disconnecting)))
+    if(s == m_state)
+        return;
+    if(s == Error && (m_state == Disconnected || m_state == Disconnecting))
         return;
+    if(m_state == Error && (s == Disconnected || s == Disconnecting))
+        return;
+
+    m_state = s;
+
     if(s == Error)
         abort();
+    else
+        m_error.clear();
     if(s == Handshaked)
         m_pingTimer.start();
     else
         m_pingTimer.stop();
-    if(m_state == Error && (s != HostLookUp && s != Connecting))
-        return;
-    m_state = s;
+
     emit stateChanged(m_state);
 }
 
 void PTSocket::setError(QString e)
 {
-    if(m_state == Error)
+    if(m_state == Error || m_state == Disconnected || m_state == Disconnecting)
         return;
-    setErrorString(e);
+    m_error = e;
     setState(Error);
 }
 
@@ -225,3 +314,10 @@ int PTSocket::byteArrayToInt(QByteArray d)
         a |= (unsigned int)((unsigned char)d.at(i) << i * 8);
     return a;
 }
+
+QDebug operator <<(QDebug dbg, const PTSocket::State s)
+{
+    const QMetaObject & mo = PTSocket::staticMetaObject;
+    QMetaEnum me = mo.enumerator(mo.indexOfEnumerator("State"));
+    return dbg<<me.valueToKey(s);
+}

libptsocket/ptsocket.h

@@ -6,6 +6,9 @@
 #include <QTcpSocket>
 #include <QHostAddress>
 #include <QTimer>
+#include <QMetaEnum>
+
+#define PT_DEBUG
 
 class LIBPTSOCKETSHARED_EXPORT PTSocket : public QTcpSocket
 {
@@ -21,10 +24,12 @@ public:
         Disconnecting,
         Error
     };
+    Q_ENUMS(State)
 	PTSocket(QObject* p);
 	int getTimeout() const;
     int getPingInterval() const;
     bool isServerSide() const;
+    QString getError() const;
 
     static QByteArray handshakeData();
 
@@ -40,6 +45,12 @@ public slots:
     void setPingInterval(int p);
     void setIsServerSide(bool s);
     void send(int pktType, QByteArray data);
+    void disconnectFromServer();
+
+    void dbgSetWillPing(bool w);
+    void dbgSetWillHandshake(bool w);
+    void dbgSetWillHandshakeFake1(bool w);
+    void dbgSetWillHandshakeFake2(bool w);
 
 private slots:
     void m_ping();
@@ -47,7 +58,7 @@ private slots:
     void m_timedout();
     void m_handshakeError();
     void m_stateChanged(QAbstractSocket::SocketState s);
-    void m_socketError(QAbstractSocket::SocketError);
+    void m_socketError(QAbstractSocket::SocketError s);
     void setState(State s);
     void setError(QString e);
     void send(bool sys, int pktType, QByteArray data = "");
@@ -60,11 +71,22 @@ private:
     State m_state;
     bool m_isServerSide;
     unsigned int m_packetSize;
+    QString m_error;
     enum PacketType
     {
         PingRequest = 1,
         PingAnswer = 2
     };
+#ifdef PT_DEBUG
+    bool m_willPing;
+    bool m_willHandshake;
+    bool m_willHandshakeFake1;
+    bool m_willHandshakeFake2;
+#endif
+#ifdef PT_DEBUG
+#endif
 };
 
+QDebug operator <<(QDebug dbg, const PTSocket::State s);
+
 #endif // PTSOCKET_H

tests/main.cpp

@@ -5,10 +5,9 @@
 int main(int argc, char *argv[])
 {
 	QCoreApplication a(argc, argv);
-	Test t;
-    t.testIntConvert();
-	t.testListen(6950);
-	t.testNewConnection();
+    Test t;
+    t.testListen(6950);
+    t.test0IntConvert();
 	
 	return a.exec();
 }

tests/test.cpp

@@ -2,51 +2,303 @@
 
 Test::Test(QObject *parent) : QObject(parent)
 {
-	m_serv = new PTServer(this);
-	connect(m_serv, SIGNAL(newConnection()), this, SLOT(m_newConnection()));
-    connect(m_serv, SIGNAL(newClient(PTSocket*)), this, SLOT(m_newClient(PTSocket*)));
+    m_serv = new PTServer(this);
+    m_timeoutTimer.setSingleShot(true);
+    connect(&m_timeoutTimer, SIGNAL(timeout()), this, SLOT(timedout()));
+    m_testsStates<<(QList<TestState>());
+    m_testsStates<<(QList<TestState>()//Basic
+                    <<TestState(1, PTSocket::HostLookUp)
+                    <<TestState(1, PTSocket::Connecting)
+                    <<TestState(1, PTSocket::Connected)
+                    <<TestState(1, PTSocket::Handshaked)
+                    <<TestState(1, PTSocket::Disconnecting)
+                    <<TestState(1, PTSocket::Disconnected)
+                    <<TestState(2, PTSocket::Disconnecting)
+                    <<TestState(2, PTSocket::Disconnected));
+    m_testsStates<<(QList<TestState>()//Ping
+                    <<TestState(1, PTSocket::HostLookUp)
+                    <<TestState(1, PTSocket::Connecting)
+                    <<TestState(1, PTSocket::Connected)
+                    <<TestState(1, PTSocket::Handshaked)
+                    <<TestState(2, PTSocket::Error)
+                    <<TestState(1, PTSocket::Disconnecting)
+                    <<TestState(1, PTSocket::Disconnected));
+    m_testsStates<<(QList<TestState>()//Handshake
+                    <<TestState(1, PTSocket::HostLookUp)
+                    <<TestState(1, PTSocket::Connecting)
+                    <<TestState(1, PTSocket::Connected)
+                    <<TestState(1, PTSocket::Handshaked)
+                    <<TestState(1, PTSocket::Disconnecting)
+                    <<TestState(1, PTSocket::Disconnected));
+    m_testsStates<<(QList<TestState>()//Handshake Fake 1
+                    <<TestState(1, PTSocket::HostLookUp)
+                    <<TestState(1, PTSocket::Connecting)
+                    <<TestState(1, PTSocket::Connected)
+                    <<TestState(1, PTSocket::Handshaked)
+                    <<TestState(1, PTSocket::Disconnecting)
+                    <<TestState(1, PTSocket::Disconnected));
+    m_testsStates<<(QList<TestState>()//Handshake Fake 2
+                    <<TestState(1, PTSocket::HostLookUp)
+                    <<TestState(1, PTSocket::Connecting)
+                    <<TestState(1, PTSocket::Connected)
+                    <<TestState(1, PTSocket::Handshaked)
+                    <<TestState(1, PTSocket::Disconnecting)
+                    <<TestState(1, PTSocket::Disconnected));
+    m_currentState = 0;
+    m_currentTest = -1;
 }
 
-void Test::testIntConvert()
+void Test::test0IntConvert()
 {
+    preTest();
     QList<int> tests;
     tests << 0 << 1 << 255 << 256 << 65535 << 65536 << -1 << -65535 << -65536 << 123456789 << -123456789;
     for(int i = 0; i < tests.size(); ++i)
-        Q_ASSERT(PTSocket::byteArrayToInt(PTSocket::intToByteArray(tests[i])) == tests[i]);
-    qDebug()<<"Int convert OK";
+    {
+        if(PTSocket::byteArrayToInt(PTSocket::intToByteArray(tests[i])) != tests[i])
+        {
+            qDebug()<<tests[i]<<PTSocket::intToByteArray(tests[i])<<PTSocket::byteArrayToInt(PTSocket::intToByteArray(tests[i]));
+            Q_ASSERT(false);
+        }
+    }
+    timeout(0);
 }
 
 void Test::testListen(quint16 p)
 {
-	Q_ASSERT(m_serv->listen(QHostAddress::Any, p));
+    Q_ASSERT(m_serv->listen(QHostAddress::Any, p));
 }
 
-void Test::testNewConnection()
+void Test::test1Basic()
 {
-	ASSERT_LISTEN;
-	PTSocket* sock = new PTSocket(this);
-    connect(sock, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(m_clientStateChanged(PTSocket::State)));
-	m_clients.append(sock);
+    preTest();
+    connect(m_serv, SIGNAL(newClient(PTSocket*)), this, SLOT(m_newClient1(PTSocket*)));
+    PTSocket* sock = newSocket();
+    connect(sock, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(m_clientStateChanged1(PTSocket::State)));
+    m_socketsIds.insert(sock, 1);
+
+    sock->connectToHost("127.0.0.1", m_serv->serverPort());
+}
+
+void Test::test2Ping()
+{
+    preTest();
+    connect(m_serv, SIGNAL(newClient(PTSocket*)), this, SLOT(m_newClient2(PTSocket*)));
+    PTSocket* sock = newSocket();
+    sock->dbgSetWillPing(false);
+    connect(sock, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(m_clientStateChanged2(PTSocket::State)));
+    m_socketsIds.insert(sock, 1);
+
+    sock->connectToHost("127.0.0.1", m_serv->serverPort());
+}
+
+void Test::test3Handshake()
+{
+    preTest();
+    connect(m_serv, SIGNAL(newClient(PTSocket*)), this, SLOT(m_newClient3(PTSocket*)));
+    PTSocket* sock = newSocket();
+    sock->dbgSetWillHandshake(false);
+    connect(sock, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(m_clientStateChanged3(PTSocket::State)));
+    m_socketsIds.insert(sock, 1);
+
+    sock->connectToHost("127.0.0.1", m_serv->serverPort());
+}
+
+void Test::test4HandshakeFake1()
+{
+    preTest();
+    connect(m_serv, SIGNAL(newClient(PTSocket*)), this, SLOT(m_newClient4(PTSocket*)));
+    PTSocket* sock = newSocket();
+    sock->dbgSetWillHandshakeFake1(true);
+    connect(sock, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(m_clientStateChanged4(PTSocket::State)));
+    m_socketsIds.insert(sock, 1);
+
     sock->connectToHost("127.0.0.1", m_serv->serverPort());
 }
 
-void Test::m_newConnection()
+void Test::test5HandshakeFake2()
 {
-	qDebug()<<"New socket";
+    preTest();
+    connect(m_serv, SIGNAL(newClient(PTSocket*)), this, SLOT(m_newClient5(PTSocket*)));
+    PTSocket* sock = newSocket();
+    sock->dbgSetWillHandshakeFake2(true);
+    connect(sock, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(m_clientStateChanged5(PTSocket::State)));
+    m_socketsIds.insert(sock, 1);
+
+    sock->connectToHost("127.0.0.1", m_serv->serverPort());
 }
 
-void Test::m_newClient(PTSocket* s)
+void Test::timeout(int i)
 {
-    connect(s, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(m_clientStateChanged(PTSocket::State)));
-    qDebug()<<"New client:"<<s->peerAddress()<<s->peerPort();
+    m_timeoutTimer.start(i);
 }
 
-void Test::m_clientStateChanged(PTSocket::State s)
+void Test::stopTimeout()
+{
+    m_timeoutTimer.stop();
+}
+
+void Test::timedout()
+{
+    if(m_currentState == m_testsStates.at(m_currentTest).size())
+    {
+        qDebug()<<"\n\nTest"<<m_currentTest<<"OK\n\n";
+
+        switch(m_currentTest)
+        {
+        case 0:
+            test1Basic();
+            break;
+        case 1:
+            test2Ping();
+            break;
+        case 2:
+            test3Handshake();
+            break;
+        case 3:
+            test4HandshakeFake1();
+            break;
+        case 4:
+            test5HandshakeFake2();
+            break;
+        default:
+            qApp->quit();
+        }
+
+    }
+    else
+    {
+        qDebug()<<"Timedout\n\n\n";
+        qDebug()<<m_currentState+1<<m_testsStates.at(m_currentTest).at(m_currentState)<<m_testsStates.at(m_currentTest);
+        Q_ASSERT(false);
+    }
+}
+
+void Test::m_clientStateChangedTest(PTSocket::State s)
 {
     PTSocket* sock = qobject_cast<PTSocket*>(sender());
-    if(sock == 0)
-        return;
-    qDebug()<<sock<<sock->isServerSide()<<s;
+    Q_ASSERT(sock != 0);
+    qDebug()<<"State"<<(sock->isServerSide()? "server": "client")<<sock<<s;
     if(s == PTSocket::Error)
-        qDebug()<<sock->errorString();
+        qDebug()<<"\t"<<sock->getError();
+    if(m_currentState >= m_testsStates.at(m_currentTest).size())
+    {
+        qDebug()<<"Out of TestState\n\n\n"<<m_socketsIds[sock]<<s;
+        Q_ASSERT(false);
+    }
+    TestState t = m_testsStates.at(m_currentTest).at(m_currentState);
+    if(!m_socketsIds.keys().contains(sock) && !m_socketsIds.values().contains(t.first))
+        m_socketsIds.insert(sock, t.first);
+
+    TestState r(m_socketsIds[sock], s);
+
+    if(r != t)
+    {
+        qDebug()<<"Test not matching\n\n\n"<<"Expected"<<t<<"but got"<<r;
+        Q_ASSERT(false);
+    }
+    ++m_currentState;
+    if(m_currentState == m_testsStates.at(m_currentTest).size())
+        timeout(1500);
+    else
+        timeout();
+}
+
+void Test::m_newClientTest(PTSocket *s)
+{
+    qDebug()<<"New client:"<<s->peerAddress().toString()<<s->peerPort();
+    timeout();
+    connect(s, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(m_clientStateChangedTest(PTSocket::State)));
+}
+
+void Test::preTest()
+{
+    ASSERT_LISTEN;
+    ++m_currentTest;
+    m_currentState = 0;
+    m_socketsIds.clear();
+    m_serv->disconnect(this);
+    connect(m_serv, SIGNAL(newConnection()), this, SLOT(timeout()));
+    connect(m_serv, SIGNAL(newClient(PTSocket*)), this, SLOT(m_newClientTest(PTSocket*)));
+}
+
+void Test::m_newClient1(PTSocket* s)
+{
+    connect(s, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(m_clientStateChanged1(PTSocket::State)));
+}
+
+void Test::m_clientStateChanged1(PTSocket::State s)
+{
+    PTSocket* sock = qobject_cast<PTSocket*>(sender());
+    if(s == PTSocket::Handshaked)
+    {
+        qDebug()<<"";
+        QTimer::singleShot(1500, sock, SLOT(disconnectFromServer()));
+    }
+}
+
+void Test::m_newClient2(PTSocket* s)
+{
+    connect(s, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(m_clientStateChanged2(PTSocket::State)));
+}
+
+void Test::m_clientStateChanged2(PTSocket::State s)
+{
+    if(s == PTSocket::Handshaked)
+        qDebug()<<"";
+}
+
+void Test::m_newClient3(PTSocket* s)
+{
+    connect(s, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(m_clientStateChanged3(PTSocket::State)));
+}
+
+void Test::m_clientStateChanged3(PTSocket::State s)
+{
+    if(s == PTSocket::Handshaked)
+        qDebug()<<"";
+}
+
+void Test::m_newClient4(PTSocket* s)
+{
+    connect(s, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(m_clientStateChanged4(PTSocket::State)));
+}
+
+void Test::m_clientStateChanged4(PTSocket::State s)
+{
+    if(s == PTSocket::Handshaked)
+        qDebug()<<"";
+}
+
+void Test::m_newClient5(PTSocket* s)
+{
+    connect(s, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(m_clientStateChanged5(PTSocket::State)));
+}
+
+void Test::m_clientStateChanged5(PTSocket::State s)
+{
+    if(s == PTSocket::Handshaked)
+        qDebug()<<"";
+}
+
+PTSocket *Test::newSocket()
+{
+    PTSocket* sock = new PTSocket(this);
+    connect(sock, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(m_clientStateChangedTest(PTSocket::State)));
+    return sock;
+}
+
+bool operator ==(TestState t1, TestState t2)
+{
+    return t1.first == t2.first && t1.second == t2.second;
+}
+
+bool operator !=(TestState t1, TestState t2)
+{
+    return !(t1 == t2);
+}
+
+QDebug operator <<(QDebug dbg, TestState t)
+{
+    return dbg<<"TestState("<<t.first<<","<<t.second<<")";
 }

tests/test.h

@@ -2,33 +2,69 @@
 #define TEST_H
 
 #include <QObject>
+#include <QCoreApplication>
+#include <QPair>
 #include "ptserver.h"
 #include "ptsocket.h"
 #include <QDebug>
 
 #define ASSERT_LISTEN Q_ASSERT(m_serv->isListening())
 
+typedef QPair<int, PTSocket::State> TestState;
+
 class Test : public QObject
 {
 	Q_OBJECT
 public:
-	explicit Test(QObject *parent = 0);
-	
-signals:
-	
+    explicit Test(QObject *parent = 0);
+
 public slots:
-    void testIntConvert();
-	void testListen(quint16 p);
-	void testNewConnection();
+    void testListen(quint16 p);
+    void test0IntConvert();
+    void test1Basic();
+    void test2Ping();
+    void test3Handshake();
+    void test4HandshakeFake1();
+    void test5HandshakeFake2();
 
 private slots:
-	void m_newConnection();
-	void m_newClient(PTSocket* s);
-    void m_clientStateChanged(PTSocket::State s);
+    void timeout(int i = 15000);
+    void stopTimeout();
+    void timedout();
+    void m_clientStateChangedTest(PTSocket::State s);
+    void m_newClientTest(PTSocket* s);
+
+    void preTest();
+
+	void m_newClient1(PTSocket* s);
+    void m_clientStateChanged1(PTSocket::State s);
+
+    void m_newClient2(PTSocket* s);
+    void m_clientStateChanged2(PTSocket::State s);
+
+    void m_newClient3(PTSocket* s);
+    void m_clientStateChanged3(PTSocket::State s);
+
+    void m_newClient4(PTSocket* s);
+    void m_clientStateChanged4(PTSocket::State s);
+
+    void m_newClient5(PTSocket* s);
+    void m_clientStateChanged5(PTSocket::State s);
+
 
 private:
-	PTServer* m_serv;
-	QList<PTSocket*> m_clients;
+    PTSocket* newSocket();
+    QTimer m_timeoutTimer;
+    PTServer* m_serv;
+    QMap<PTSocket*, int> m_socketsIds;
+    QList<QList<TestState> > m_testsStates;
+    int m_currentTest;
+    int m_currentState;
+
 };
 
+bool operator ==(TestState t1, TestState t2);
+bool operator !=(TestState t1, TestState t2);
+QDebug operator <<(QDebug dbg, TestState t);
+
 #endif // TEST_H