/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QtTest/QtTest>

#include <qtextstream.h>

#include <QtNetwork/qlocalsocket.h>

#include <QtNetwork/qlocalserver.h>

#include "../../shared/util.h"

#ifdef Q_OS_SYMBIAN

    #include <unistd.h>

#endif

//TESTED_CLASS=QLocalServer, QLocalSocket

//TESTED_FILES=network/socket/qlocalserver.cpp network/socket/qlocalsocket.cpp

#ifdef Q_OS_SYMBIAN

    #define STRINGIFY(x) #x

    #define TOSTRING(x) STRINGIFY(x)

    #define SRCDIR "C:/Private/" TOSTRING(SYMBIAN_SRCDIR_UID) "/"

#endif

Q_DECLARE_METATYPE(QLocalSocket::LocalSocketError)

Q_DECLARE_METATYPE(QLocalSocket::LocalSocketState)

class tst_QLocalSocket : public QObject

{

    Q_OBJECT

public:

    tst_QLocalSocket();

    virtual ~tst_QLocalSocket();

public Q_SLOTS:

    void init();

    void cleanup();

private slots:

    // basics

    void server_basic();

    void server_connectionsCount();

    void socket_basic();

    void listen_data();

    void listen();

    void listenAndConnect_data();

    void listenAndConnect();

    void sendData_data();

    void sendData();

    void readBufferOverflow();

    void fullPath();

    void hitMaximumConnections_data();

    void hitMaximumConnections();

    void setSocketDescriptor();

    void threadedConnection_data();

    void threadedConnection();

    void processConnection_data();

    void processConnection();

    void longPath();

    void waitForDisconnect();

    void waitForDisconnectByServer();

    void removeServer();

    void recycleServer();

    void multiConnect();

    void writeOnlySocket();

    void writeToClientAndDisconnect();

    void debug();

    void bytesWrittenSignal();

#ifdef Q_OS_SYMBIAN

private:

    void unlink(QString serverName);

#endif

};

tst_QLocalSocket::tst_QLocalSocket()

{

    if (!QFile::exists("lackey/lackey"

#ifdef Q_OS_WIN

    ".exe"

#endif

                ))

        qWarning() << "lackey executable doesn't exists!";

}

tst_QLocalSocket::~tst_QLocalSocket()

{

}

void tst_QLocalSocket::init()

{

    qRegisterMetaType<QLocalSocket::LocalSocketState>("QLocalSocket::LocalSocketState");

    qRegisterMetaType<QLocalSocket::LocalSocketError>("QLocalSocket::LocalSocketError");

}

void tst_QLocalSocket::cleanup()

{

}

class LocalServer : public QLocalServer

{

    Q_OBJECT

public:

    LocalServer() : QLocalServer()

    {

        connect(this, SIGNAL(newConnection()), this, SLOT(slotNewConnection()));

    }

    bool listen(const QString &name)

    {

        removeServer(name);

        return QLocalServer::listen(name);

    }

    QList<int> hits;

protected:

    void incomingConnection(quintptr socketDescriptor)

    {

        hits.append(socketDescriptor);

        QLocalServer::incomingConnection(socketDescriptor);

    }

private slots:

    void slotNewConnection() {

        QVERIFY(!hits.isEmpty());

        QVERIFY(hasPendingConnections());

    }

};

class LocalSocket : public QLocalSocket

{

    Q_OBJECT

public:

    LocalSocket(QObject *parent = 0) : QLocalSocket(parent)

    {

        connect(this, SIGNAL(connected()),

                this, SLOT(slotConnected()));

        connect(this, SIGNAL(disconnected()),

                this, SLOT(slotDisconnected()));

        connect(this, SIGNAL(error(QLocalSocket::LocalSocketError)),

                this, SLOT(slotError(QLocalSocket::LocalSocketError)));

        connect(this, SIGNAL(stateChanged(QLocalSocket::LocalSocketState)),

                this, SLOT(slotStateChanged(QLocalSocket::LocalSocketState)));

        connect(this, SIGNAL(readyRead()),

                this, SLOT(slotReadyRead()));

    }

private slots:

    void slotConnected()

    {

        QCOMPARE(state(), QLocalSocket::ConnectedState);

    }

    void slotDisconnected()

    {

        QCOMPARE(state(), QLocalSocket::UnconnectedState);

    }

    void slotError(QLocalSocket::LocalSocketError newError)

    {

        QVERIFY(errorString() != "Unknown error");

        QCOMPARE(error(), newError);

    }

    void slotStateChanged(QLocalSocket::LocalSocketState newState)

    {

        QCOMPARE(state(), newState);

    }

    void slotReadyRead()

    {

        QVERIFY(bytesAvailable() > 0);

    }

};

// basic test make sure no segfaults and check default values

void tst_QLocalSocket::server_basic()

{

    LocalServer server;

    QSignalSpy spyNewConnection(&server, SIGNAL(newConnection()));

    server.close();

    QCOMPARE(server.errorString(), QString());

    QCOMPARE(server.hasPendingConnections(), false);

    QCOMPARE(server.isListening(), false);

    QCOMPARE(server.maxPendingConnections(), 30);

    QCOMPARE(server.nextPendingConnection(), (QLocalSocket*)0);

    QCOMPARE(server.serverName(), QString());

    QCOMPARE(server.fullServerName(), QString());

    QCOMPARE(server.serverError(), QAbstractSocket::UnknownSocketError);

    server.setMaxPendingConnections(20);

    bool timedOut = true;

    QCOMPARE(server.waitForNewConnection(3000, &timedOut), false);

    QVERIFY(!timedOut);

    QCOMPARE(server.listen(QString()), false);

    QCOMPARE(server.hits.count(), 0);

    QCOMPARE(spyNewConnection.count(), 0);

}

void tst_QLocalSocket::server_connectionsCount()

{

    LocalServer server;

    server.setMaxPendingConnections(10);

    QCOMPARE(server.maxPendingConnections(), 10);

}

// basic test make sure no segfaults and check default values

void tst_QLocalSocket::socket_basic()

{

    LocalSocket socket;

    QSignalSpy spyConnected(&socket, SIGNAL(connected()));

    QSignalSpy spyDisconnected(&socket, SIGNAL(disconnected()));

    QSignalSpy spyError(&socket, SIGNAL(error(QLocalSocket::LocalSocketError)));

    QSignalSpy spyStateChanged(&socket, SIGNAL(stateChanged(QLocalSocket::LocalSocketState)));

    QSignalSpy spyReadyRead(&socket, SIGNAL(readyRead()));

    QCOMPARE(socket.serverName(), QString());

    QCOMPARE(socket.fullServerName(), QString());

    socket.abort();

    QVERIFY(socket.bytesAvailable() == 0);

    QVERIFY(socket.bytesToWrite() == 0);

    QCOMPARE(socket.canReadLine(), false);

    socket.close();

    socket.disconnectFromServer();

    QCOMPARE(QLocalSocket::UnknownSocketError, socket.error());

    QVERIFY(socket.errorString() != QString());

    QCOMPARE(socket.flush(), false);

    QCOMPARE(socket.isValid(), false);

    QVERIFY(socket.readBufferSize() == 0);

    socket.setReadBufferSize(0);

    //QCOMPARE(socket.socketDescriptor(), -1);

    QCOMPARE(socket.state(), QLocalSocket::UnconnectedState);

    QCOMPARE(socket.waitForConnected(0), false);

    QCOMPARE(socket.waitForDisconnected(0), false);

    QCOMPARE(socket.waitForReadyRead(0), false);

    QCOMPARE(spyConnected.count(), 0);

    QCOMPARE(spyDisconnected.count(), 0);

    QCOMPARE(spyError.count(), 0);

    QCOMPARE(spyStateChanged.count(), 0);

    QCOMPARE(spyReadyRead.count(), 0);

}

void tst_QLocalSocket::listen_data()

{

    QTest::addColumn<QString>("name");

    QTest::addColumn<bool>("canListen");

    QTest::addColumn<bool>("close");

    QTest::newRow("null") << QString() << false << false;

    QTest::newRow("tst_localsocket") << "tst_localsocket" << true << true;

    QTest::newRow("tst_localsocket") << "tst_localsocket" << true << false;

}

// start a server that listens, but don't connect a socket, make sure everything is in order

void tst_QLocalSocket::listen()

{

    LocalServer server;

    QSignalSpy spyNewConnection(&server, SIGNAL(newConnection()));

    QFETCH(QString, name);

#ifdef Q_OS_SYMBIAN

    unlink(name);

#endif

    QFETCH(bool, canListen);

    QFETCH(bool, close);

    QVERIFY2((server.listen(name) == canListen), server.errorString().toLatin1().constData());

    // test listening

    QCOMPARE(server.serverName(), name);

    QVERIFY(server.fullServerName().contains(name));

    QCOMPARE(server.isListening(), canListen);

    QCOMPARE(server.hasPendingConnections(), false);

    QCOMPARE(server.nextPendingConnection(), (QLocalSocket*)0);

    QCOMPARE(server.hits.count(), 0);

    QCOMPARE(spyNewConnection.count(), 0);

    if (canListen) {

        QVERIFY(server.errorString() == QString());

        QCOMPARE(server.serverError(), QAbstractSocket::UnknownSocketError);

        // already isListening

        QVERIFY(!server.listen(name));

    } else {

        QVERIFY(server.errorString() != QString());

        QCOMPARE(server.serverError(), QAbstractSocket::HostNotFoundError);

    }

    QCOMPARE(server.maxPendingConnections(), 30);

    bool timedOut = false;

    QCOMPARE(server.waitForNewConnection(3000, &timedOut), false);

    QCOMPARE(timedOut, canListen);

    if (close)

        server.close();

}

void tst_QLocalSocket::listenAndConnect_data()

{

    QTest::addColumn<QString>("name");

    QTest::addColumn<bool>("canListen");

    QTest::addColumn<int>("connections");

    for (int i = 0; i < 3; ++i) {

        int connections = i;

        if (i == 2)

            connections = 5;

        QTest::newRow(QString("null %1").arg(i).toLatin1()) << QString() << false << connections;

        QTest::newRow(QString("tst_localsocket %1").arg(i).toLatin1()) << "tst_localsocket" << true << connections;

    }

}

void tst_QLocalSocket::listenAndConnect()

{

    LocalServer server;

    QSignalSpy spyNewConnection(&server, SIGNAL(newConnection()));

    QFETCH(QString, name);

    QFETCH(bool, canListen);

#ifdef Q_OS_SYMBIAN

    unlink(name);

#endif

    QCOMPARE(server.listen(name), canListen);

    QTest::qWait(1000);

    //QVERIFY(!server.errorString().isEmpty());

    QCOMPARE(server.serverError(),

            canListen ? QAbstractSocket::UnknownSocketError : QAbstractSocket::HostNotFoundError);

    // test creating connection(s)

    QFETCH(int, connections);

    QList<QLocalSocket*> sockets;

    for (int i = 0; i < connections; ++i) {

        LocalSocket *socket = new LocalSocket;

        QSignalSpy spyConnected(socket, SIGNAL(connected()));

        QSignalSpy spyDisconnected(socket, SIGNAL(disconnected()));

        QSignalSpy spyError(socket, SIGNAL(error(QLocalSocket::LocalSocketError)));

        QSignalSpy spyStateChanged(socket, SIGNAL(stateChanged(QLocalSocket::LocalSocketState)));

        QSignalSpy spyReadyRead(socket, SIGNAL(readyRead()));

        socket->connectToServer(name);

#if defined(QT_LOCALSOCKET_TCP)

        QTest::qWait(250);

#endif

        QCOMPARE(socket->serverName(), name);

        QVERIFY(socket->fullServerName().contains(name));

        sockets.append(socket);

        if (canListen) {

            QCOMPARE(socket->errorString(), QString("Unknown error"));

            QCOMPARE(socket->error(), QLocalSocket::UnknownSocketError);

            QCOMPARE(socket->state(), QLocalSocket::ConnectedState);

            //QVERIFY(socket->socketDescriptor() != -1);

            QCOMPARE(spyError.count(), 0);

        } else {

            QVERIFY(socket->errorString() != QString());

            QVERIFY(socket->error() != QLocalSocket::UnknownSocketError);

            QCOMPARE(socket->state(), QLocalSocket::UnconnectedState);

            //QVERIFY(socket->socketDescriptor() == -1);

            QCOMPARE(qVariantValue<QLocalSocket::LocalSocketError>(spyError.first()[0]),

                     QLocalSocket::ServerNotFoundError);

        }

        QVERIFY(socket->bytesAvailable() == 0);

        QVERIFY(socket->bytesToWrite() == 0);

        QCOMPARE(socket->canReadLine(), false);

        QCOMPARE(socket->flush(), false);

        QCOMPARE(socket->isValid(), canListen);

        QCOMPARE(socket->readBufferSize(), (qint64)0);

        QCOMPARE(socket->waitForConnected(0), canListen);

        QCOMPARE(socket->waitForReadyRead(0), false);

        QTRY_COMPARE(spyConnected.count(), canListen ? 1 : 0);

        QCOMPARE(spyDisconnected.count(), 0);

        // error signals

        QVERIFY(spyError.count() >= 0);

        if (canListen) {

            if (spyError.count() > 0)

                QCOMPARE(qVariantValue<QLocalSocket::LocalSocketError>(spyError.first()[0]),

                         QLocalSocket::SocketTimeoutError);

        } else {

            QCOMPARE(qVariantValue<QLocalSocket::LocalSocketError>(spyError.first()[0]),

                     QLocalSocket::ServerNotFoundError);

        }

        // Check first and last state

        QCOMPARE(qVariantValue<QLocalSocket::LocalSocketState>(spyStateChanged.first()[0]),

                 QLocalSocket::ConnectingState);

#if 0

        for (int j = 0; j < spyStateChanged.count(); ++j) {

            QLocalSocket::LocalSocketState s;

            s = qVariantValue<QLocalSocket::LocalSocketState>(spyStateChanged.at(j).at(0));

            qDebug() << s;

        }

#endif

        if (canListen)

            QCOMPARE(qVariantValue<QLocalSocket::LocalSocketState>(spyStateChanged.last()[0]),

                     QLocalSocket::ConnectedState);

        QCOMPARE(spyStateChanged.count(), 2);

        QCOMPARE(spyReadyRead.count(), 0);

        bool timedOut = true;

        QCOMPARE(server.waitForNewConnection(3000, &timedOut), canListen);

        QVERIFY(!timedOut);

        QCOMPARE(server.hasPendingConnections(), canListen);

        QCOMPARE(server.isListening(), canListen);

        // NOTE: socket disconnecting is not tested here

        // server checks post connection

        if (canListen) {

            QCOMPARE(server.serverName(), name);

            QVERIFY(server.fullServerName().contains(name));

            QVERIFY(server.nextPendingConnection() != (QLocalSocket*)0);

            QTRY_COMPARE(server.hits.count(), i + 1);

            QCOMPARE(spyNewConnection.count(), i + 1);

            QVERIFY(server.errorString() == QString());

            QCOMPARE(server.serverError(), QAbstractSocket::UnknownSocketError);

        } else {

            QVERIFY(server.serverName().isEmpty());

            QVERIFY(server.fullServerName().isEmpty());

            QVERIFY(server.nextPendingConnection() == (QLocalSocket*)0);

            QCOMPARE(spyNewConnection.count(), 0);

            QCOMPARE(server.hits.count(), 0);

            QVERIFY(server.errorString() != QString());

            QCOMPARE(server.serverError(), QAbstractSocket::HostNotFoundError);

        }

    }

    qDeleteAll(sockets.begin(), sockets.end());

    server.close();

    QCOMPARE(server.hits.count(), (canListen ? connections : 0));

    QCOMPARE(spyNewConnection.count(), (canListen ? connections : 0));

}

void tst_QLocalSocket::sendData_data()

{

    listenAndConnect_data();

}

void tst_QLocalSocket::sendData()

{

    QFETCH(QString, name);

#ifdef Q_OS_SYMBIAN

    unlink(name);

#endif

    QFETCH(bool, canListen);

    LocalServer server;

    QSignalSpy spy(&server, SIGNAL(newConnection()));

    QCOMPARE(server.listen(name), canListen);

    LocalSocket socket;

    QSignalSpy spyConnected(&socket, SIGNAL(connected()));

    QSignalSpy spyDisconnected(&socket, SIGNAL(disconnected()));

    QSignalSpy spyError(&socket, SIGNAL(error(QLocalSocket::LocalSocketError)));

    QSignalSpy spyStateChanged(&socket, SIGNAL(stateChanged(QLocalSocket::LocalSocketState)));

    QSignalSpy spyReadyRead(&socket, SIGNAL(readyRead()));

    // test creating a connection

    socket.connectToServer(name);

    bool timedOut = true;

    QCOMPARE(server.waitForNewConnection(3000, &timedOut), canListen);

#if defined(QT_LOCALSOCKET_TCP)

    QTest::qWait(250);

#endif

    QVERIFY(!timedOut);

    QCOMPARE(spyConnected.count(), canListen ? 1 : 0);

    QCOMPARE(socket.state(), canListen ? QLocalSocket::ConnectedState : QLocalSocket::UnconnectedState);

    // test sending/receiving data

    if (server.hasPendingConnections()) {

        QString testLine = "test";

#ifdef Q_OS_SYMBIAN

        for (int i = 0; i < 25 * 1024; ++i)

#else

        for (int i = 0; i < 50000; ++i)

#endif

            testLine += "a";

        QLocalSocket *serverSocket = server.nextPendingConnection();

        QVERIFY(serverSocket);