TcpTransportFactoryTest.cpp

Go to the documentation of this file.

/*

Copyright (C) 2006-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Calitko is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#include "Qt.h"
#include "../TcpTransportFactory.h"
#include "../Transport.h"
#include "generated/TcpTransportFactoryDriver.h"
#include "generated/TransportFactoryStatusMock.h"
#include "generated/TransportStatusMock.h"
#include "TcpTester.h"
#include "Imports.cpp"

namespace Protocols {
namespace Generics {
namespace Testing {

class TransportCreatedChecker
{
    Uri uri_;
    TransportStatus *status_;

public:
    static Transport *checkedTransport;

    TransportCreatedChecker (const Uri &uri, TransportStatus *status)
    : uri_ (uri), status_ (status) {}

    typedef void (Function) (const Uri &, Transport *);

    bool check (const Uri &uri, Transport *transport)
    {
        checkedTransport = transport;
        checkedTransport->setTransportStatus (status_);
        CPPUNIT_ASSERT (uri_ == uri);
        CPPUNIT_ASSERT (transport != 0);
/*      CPPUNIT_ASSERT (dynamic_cast <SocketTransport *>
                            (transport) != 0);*/
        return true;
    }
};

Transport * TransportCreatedChecker::checkedTransport = 0;


class TcpTransportFactoryTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (TcpTransportFactoryTest);
    CPPUNIT_TEST (testCreateTcpTransportForIpFails);
    CPPUNIT_TEST (testCreateTcpTransportForIpSucceeds);
    CPPUNIT_TEST (testDestroyTcpTransport);
    CPPUNIT_TEST (testReadBufferIs40Bytes);
    CPPUNIT_TEST (testWriteBufferIs40Bytes);
    CPPUNIT_TEST (testReadBufferIs800Bytes);
    CPPUNIT_TEST (testWriteBufferIs800Bytes);
    CPPUNIT_TEST_SUITE_END();

    auto_ptr <TcpTester>                    tcpTester;
    auto_ptr <TransportStatusMock>          transportStatus;
    auto_ptr <TransportFactoryStatusMock>   status;
    auto_ptr <TcpTransportFactory>          factoryReal;
    auto_ptr <TcpTransportFactoryDriver>    factory;

    Uri                                     tcpUri40ByteBuffers;
    Uri                                     tcpUri800ByteBuffers;

public:
    void setUp()
    {
        tcpTester.reset (new TcpTester);
        transportStatus.reset (new TransportStatusMock);
        status.reset (new TransportFactoryStatusMock);
        factoryReal.reset (new TcpTransportFactory);
        factory.reset (new TcpTransportFactoryDriver (*factoryReal));

        tcpUri40ByteBuffers = Uri::fromUnencoded (
            "tcp://" + tcpTester->connectAddress() + "?rb=40&wb=40");
        tcpUri800ByteBuffers = Uri::fromUnencoded (
            "tcp://" + tcpTester->connectAddress() + "?rb=800&wb=800");
    }

    void tearDown()
    {
        factory.reset();
        factoryReal.reset();
        status.reset();
        transportStatus.reset();
        tcpTester.reset();
    }

    void refCreatingTransport (const Uri &uri)
    {
        call (factory->createTransport (uri, *status))
        .returns();
    }

    void refWaitForTransportCreationToFail (const Uri &uri)
    {
        waitFor (10000)
            .willCall (status->transportFactoryFailed (uri))
            .returns()
        .returns();
    }

    void testCreateTcpTransportForIpFails()
    {
        tcpTester->rejectConnections();
        refCreatingTransport (tcpUri40ByteBuffers);
        refWaitForTransportCreationToFail (tcpUri40ByteBuffers);
    }

    void refWaitForTransportCreationToSucceed (const Uri &uri)
    {
        waitFor (10000)
            .willCall (status->transportFactorySucceeded (checker (
                            TransportCreatedChecker(uri, *transportStatus))))
            .returns()
        .returns();
    }

    void stateTransportCreated (const Uri &uri)
    {
        refCreatingTransport (uri);
        tcpTester->acceptConnection();
        refWaitForTransportCreationToSucceed (uri);
    }

    void testCreateTcpTransportForIpSucceeds()
    {
        stateTransportCreated (tcpUri40ByteBuffers);
        // The TcpTransportFactory dtor would delete the created transport
        // object, however the caller should explicitly destroy it (see
        // testDestroyTcpTransport()).
    }

    void testDestroyTcpTransport()
    {
        testCreateTcpTransportForIpSucceeds();

        call (factory->destroyTransport (
                            TransportCreatedChecker::checkedTransport))
        .returns();
    }

    void refReadBufferSize (Transport *transport, int size)
    {
        CPPUNIT_ASSERT (transport != 0);

        tcpTester->bytesToWrite = QByteArray (size + 1, '1');
        tcpTester->writeBytes();

        // \note \a size is supposed to be small enough, so that it is
        // enough to run the event loop until the first notification is sent
        // (default waitFor() behavior):
        waitFor (2000)
            .willCall (transportStatus->transportReadyRead (transport))
            .returns()
        .returns();

        CPPUNIT_ASSERT (transport->canRead (size) == true);
        CPPUNIT_ASSERT (transport->canRead (size + 1) == false);
    }

    void refWriteBufferSize (Transport *transport, int size)
    {
        CPPUNIT_ASSERT (transport != 0);
        CPPUNIT_ASSERT (transport->canWrite (size) == true);
        CPPUNIT_ASSERT (transport->canWrite (size + 1) == false);
    }

    void testReadBufferIs40Bytes()
    {
        stateTransportCreated (tcpUri40ByteBuffers);
        refReadBufferSize (TransportCreatedChecker::checkedTransport, 40);
    }

    void testWriteBufferIs40Bytes()
    {
        stateTransportCreated (tcpUri40ByteBuffers);
        refWriteBufferSize (TransportCreatedChecker::checkedTransport, 40);
    }

    void testReadBufferIs800Bytes()
    {
        stateTransportCreated (tcpUri800ByteBuffers);
        refReadBufferSize (TransportCreatedChecker::checkedTransport, 800);
    }

    void testWriteBufferIs800Bytes()
    {
        stateTransportCreated (tcpUri800ByteBuffers);
        refWriteBufferSize (TransportCreatedChecker::checkedTransport, 800);
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION (TcpTransportFactoryTest);

} // namespace Testing
} // namespace Generics
} // namespace Protocols

Copyright © 2006 Peter Dimov.
Powered by Doxygen.