TcpSocketBufferTest.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 "generated/TcpSocketBufferDriver.h"
#include "generated/SocketMock.h"
#include "Imports.h"

namespace Protocols {
namespace Generics {
namespace Testing {

class WriteCallChecker
{
    QByteArray bytes;

public:
    WriteCallChecker (const QByteArray &bytes_)
    : bytes (bytes_) {}

    typedef qint64 (Function) (const char *, qint64);

    bool check (const char *source, qint64 size)
    {
        QByteArray checkBytes = QByteArray::fromRawData (source, size);
        return checkBytes == bytes;
    }
};

class ReadCallChecker
{
    QByteArray bytes;

public:
    ReadCallChecker (const QByteArray &bytes_)
    : bytes (bytes_) {}

    typedef qint64 (Function) (char *, qint64);

    bool check (char *destination, qint64 size)
    {
        // We expect a buffer that would fit our bytes.
        if (size < bytes.size())
            return false;
        int count = std::min (static_cast <int> (size), bytes.size());
        memcpy (destination, bytes.constData(), count);
        return true;
    }
};


class TcpSocketBufferTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (TcpSocketBufferTest);
    CPPUNIT_TEST (testWritingZeroBytesAlwaysSucceeds);
    CPPUNIT_TEST (testWriteBufferSizeBytesAtOnce);
    CPPUNIT_TEST (testWriteBufferSizeBytesAtOnceTwoTimes);
    CPPUNIT_TEST (testWriteBufferSizeBytesAtTwoWrites);
    CPPUNIT_TEST (testWriteMoreThanBufferSize);
    CPPUNIT_TEST (testPartialWriteToSocket7of10);
    CPPUNIT_TEST (testPartialWriteToSocket0of10);
    CPPUNIT_TEST (testPartialWriteToSocket_1of10);
    CPPUNIT_TEST (testPartialWriteToSocketWithRotate3ofLast5);
    CPPUNIT_TEST (testPartialWriteToSocketWithRotate0ofLast5);
    CPPUNIT_TEST (testPartialWriteToSocketWithRotate_1ofLast5);
    CPPUNIT_TEST (testTryReadFromFillsBuffer);
    CPPUNIT_TEST (testTryReadFromReadsNothing);
    CPPUNIT_TEST (testReadingZeroBytesAlwaysSucceeds);
    CPPUNIT_TEST (testReadsWhatWasReadFrom5rotate5);
    CPPUNIT_TEST (testReadsWhatWasReadFrom5rotate0);
    CPPUNIT_TEST (testTryReadFromAtOnceSocketReadReturns_1NoDataLost);
    CPPUNIT_TEST (testTryReadFromAtTwoReadsSocketReadReturns_1NoDataLost);
    CPPUNIT_TEST (testTryReadFromOnceThemMultipleNormalReads);
    CPPUNIT_TEST (testReadAll);
    CPPUNIT_TEST (testPeekAndPeekAll);
    CPPUNIT_TEST (testPeekToAndReadTo);
    CPPUNIT_TEST (testPeekToAndReadToWhenSeparatorInTwoChunks);
    CPPUNIT_TEST (testCanRead);
    CPPUNIT_TEST (testCanWrite);
    CPPUNIT_TEST (testPeekAtMostThenReadAtMost);
    CPPUNIT_TEST_SUITE_END();

    static const int ReadBufferSize     = 20;
    static const int WriteBufferSize    = 20;

    auto_ptr <SocketMock>               socket;
    auto_ptr <TcpSocketBuffer>          buffer_real;
    auto_ptr <TcpSocketBufferDriver>    buffer;

public:
    TcpSocketBufferTest() : socket(), buffer_real(), buffer()
    {
    }

    void setUp()
    {
        socket.reset (new SocketMock);
        buffer_real.reset (new TcpSocketBuffer (ReadBufferSize,
                                                WriteBufferSize));
        buffer.reset (new TcpSocketBufferDriver (*buffer_real.get()));
    }

    void tearDown()
    {
        buffer.reset();
        buffer_real.reset();
        socket.reset();
    }

    void refWriteBytesFails (const QByteArray &bytes, bool flush = true)
    {
        call (buffer->write (bytes, flush))
        .willReturn (false);
    }

    void refWriteBytesSucceeds (const QByteArray &bytes, bool flush = true)
    {
        call (buffer->write (bytes, flush))
        .willReturn (true);
    }

    void testWritingZeroBytesAlwaysSucceeds()
    {
        refWriteBytesSucceeds (QByteArray(), true);
        refWriteBytesSucceeds (QByteArray(), false);
    }

    void testWriteBufferSizeBytesAtOnce()
    {
        refWriteBytesSucceeds (QByteArray (WriteBufferSize, '1'));
        refWriteBytesFails (QByteArray (1, '1')); // No more data should fit.
    }

    void testWriteBufferSizeBytesAtOnceTwoTimes()
    {
        testWriteBufferSizeBytesAtOnce();
        refWriteToSocketAtOnce (QByteArray (WriteBufferSize, '1'));
        // Try the same a second time.
        testWriteBufferSizeBytesAtOnce();
    }

    void testWriteBufferSizeBytesAtTwoWrites()
    {
        refWriteBytesSucceeds (QByteArray (1, '1'));
        refWriteBytesSucceeds (QByteArray (WriteBufferSize - 1, '1'));
        refWriteBytesFails (QByteArray (1, '1')); // No more data should fit.
    }

    void testWriteMoreThanBufferSize()
    {
        refWriteBytesFails (QByteArray (WriteBufferSize + 1, '1'));
    }

    void refWriteToSocketAtOnce (const QByteArray &bytes)
    {
        refWriteToSocketAtOncePartially (bytes, bytes.count());
    }

    void refWriteToSocketAtOncePartially (const QByteArray &bytes,
                                          int countWritten)
    {
        Q_ASSERT (countWritten <= bytes.size());
        call (buffer->tryWriteTo (*socket))
            .willCall (socket->write (checker (WriteCallChecker (bytes))))
            .willReturn (countWritten)
        .returns();
    }


    void refWriteToSocketAtTwoChunks (const QByteArray &bytes1,
                                      const QByteArray &bytes2)
    {
        // A special case of partially is writing all of the second array:
        refWriteToSocketAtTwoChunksSecondPartially (bytes1, bytes2,
                                                    bytes2.size());
    }

    void refWriteToSocketAtTwoChunksSecondPartially (const QByteArray &bytes1,
                                                     const QByteArray &bytes2,
                                                     int countWrittenBytes2)
    {
        Q_ASSERT (countWrittenBytes2 <= bytes2.size());
        call (buffer->tryWriteTo (*socket))
            .willCall (socket->write (checker (WriteCallChecker (bytes1))))
            .willReturn (bytes1.size())
            .willCall (socket->write (checker (WriteCallChecker (bytes2))))
            .willReturn (countWrittenBytes2)
        .returns();
    }

    void testRingBufferRotate()
    {
        refWriteBytesSucceeds (QByteArray (5, '1'));
        refWriteToSocketAtOnce (QByteArray (5, '1'));
        // This write should write the bytes in two chunks.
        refWriteBytesSucceeds (QByteArray (WriteBufferSize, '1'));
        refWriteToSocketAtTwoChunks (QByteArray (WriteBufferSize - 5, '1'),
                                     QByteArray (5, '1'));
    }


    void scenarioPartialWriteToSocketDoesNotLooseData (int countAll,
                                                       int countWritten)
    {
        QByteArray bytes (countAll, '1');
        refWriteBytesSucceeds (bytes);
        refWriteToSocketAtOncePartially (bytes, countWritten);
        // The subsequent write should only write the rest of the bytes.
        refWriteToSocketAtOnce (bytes.mid (countWritten));
    }

    void testPartialWriteToSocket7of10()
    {
        scenarioPartialWriteToSocketDoesNotLooseData (10, 7);
    }

    void testPartialWriteToSocket0of10()
    {
        scenarioPartialWriteToSocketDoesNotLooseData (10, 0);
    }

    void testPartialWriteToSocket_1of10()
    {
        scenarioPartialWriteToSocketDoesNotLooseData (10, -1);
    }


    void scenarioPartialWriteToSocketWithRotationDoesNotLoseData (int offset,
                                                                  int count)
    {
        Q_ASSERT (offset > 0);
        Q_ASSERT (offset <= WriteBufferSize);
        QByteArray bytes1 (offset, '1');
        QByteArray bytes2 (WriteBufferSize, '1');
        QByteArray bytes2chunk1 = bytes2.left (WriteBufferSize - offset);
        QByteArray bytes2chunk2 = bytes2.mid (WriteBufferSize - offset);

        refWriteBytesSucceeds (bytes1);
        refWriteToSocketAtOnce (bytes1);
        // This write should write the bytes in two chunks (second partially).
        refWriteBytesSucceeds (bytes2);
        refWriteToSocketAtTwoChunksSecondPartially (bytes2chunk1, bytes2chunk2,
                                                    count);
        // Subsequent tryWriteTo() should only try to write the rest.
        refWriteToSocketAtOnce (bytes2chunk2.mid (count));
    }

    void testPartialWriteToSocketWithRotate3ofLast5()
    {
        scenarioPartialWriteToSocketWithRotationDoesNotLoseData (5, 3);
    }

    void testPartialWriteToSocketWithRotate0ofLast5()
    {
        scenarioPartialWriteToSocketWithRotationDoesNotLoseData (5, 0);
    }

    void testPartialWriteToSocketWithRotate_1ofLast5()
    {
        scenarioPartialWriteToSocketWithRotationDoesNotLoseData (5, -1);
    }

    void refReadBytesSucceeds (const QByteArray &bytes)
    {
        call (buffer->read (bytes.count()))
        .willReturn (bytes);
    }

    void refReadBytesFails (int count)
    {
        call (buffer->read (count))
        .willReturn (QByteArray());
    }

    void refTryReadFromAtOnce (const QByteArray &bytes)
    {
        call (buffer->tryReadFrom (*socket))
            .willCall (socket->read (checker (ReadCallChecker (bytes))))
            .willReturn (bytes.size())
        .returns();
    }


    void refTryReadFromAtTwoReads (const QByteArray &bytes1,
                                   const QByteArray &bytes2)
    {
        call (buffer->tryReadFrom (*socket))
            .willCall (socket->read (checker (ReadCallChecker (bytes1))))
            .willReturn (bytes1.size())
            .willCall (socket->read (checker (ReadCallChecker (bytes2))))
            .willReturn (bytes2.size())
        .returns();
    }

    void testTryReadFromFillsBuffer()
    {
        refTryReadFromAtOnce (QByteArray (ReadBufferSize, '1'));
    }

    void testTryReadFromReadsNothing()
    {
        refTryReadFromAtOnce (QByteArray());
    }

    void testReadingZeroBytesAlwaysSucceeds()
    {
        // The two are equivalent. Furthermore the read buffer is empty.
        refReadBytesSucceeds (QByteArray());
        refReadBytesFails (0);
        // We should be allowed to read nothing even if there is something.
        testTryReadFromFillsBuffer();
        refReadBytesSucceeds (QByteArray());
    }


    void scenarioReadsWhatWasReadFrom (int offset, int secondSize)
    {
        Q_ASSERT (offset <= ReadBufferSize);
        QByteArray bytes1 (offset, '1');
        QByteArray bytes2 (ReadBufferSize - offset, '2');
        QByteArray bytes3 (secondSize, '2');

        refTryReadFromAtOnce (bytes1);
        refReadBytesSucceeds (bytes1);
        refTryReadFromAtTwoReads (bytes2, bytes3);
        refReadBytesSucceeds (bytes2 + bytes3);
    }

    void testReadsWhatWasReadFrom5rotate5()
    {
        scenarioReadsWhatWasReadFrom  (5, 5);
    }

    void testReadsWhatWasReadFrom5rotate0()
    {
        scenarioReadsWhatWasReadFrom  (5, 0);
    }

    void testTryReadFromAtOnceSocketReadReturns_1NoDataLost()
    {
        QByteArray bytes ("1234567890");
        refTryReadFromAtOnce (bytes);

        call (buffer->tryReadFrom (*socket))
            .willCall (socket->read (checker (ReadCallChecker (QByteArray()))))
            .willReturn (-1)
        .returns();

        refReadBytesSucceeds (bytes);
    }

    void testTryReadFromAtTwoReadsSocketReadReturns_1NoDataLost()
    {
        QByteArray bytes1 (5, '1');
        QByteArray bytes2 (ReadBufferSize - 5, '1');

        refTryReadFromAtOnce (bytes1);
        refReadBytesSucceeds (bytes1);

        call (buffer->tryReadFrom (*socket))
            .willCall (socket->read (checker (ReadCallChecker (bytes2))))
            .willReturn (bytes2.size())
            .willCall (socket->read (checker (ReadCallChecker (QByteArray()))))
            .willReturn (-1)
        .returns();
        refReadBytesSucceeds (bytes2);
    }

    void testTryReadFromOnceThemMultipleNormalReads()
    {
        QByteArray bytes ("1234567890");
        refTryReadFromAtOnce (bytes);
        refReadBytesSucceeds (bytes.left (3));
        refReadBytesSucceeds (bytes.mid (3, 3));
        refReadBytesSucceeds (bytes.mid (6));
    }

    void testReadAll()
    {
        // All bytes are stored as one chunk in the buffer.
        QByteArray bytes1 (10, '1');
        refTryReadFromAtOnce (bytes1);

        call (buffer->readAll())
        .willReturn (bytes1);

        // All bytes are stored as two chunks in the buffer.
        QByteArray bytes2 (ReadBufferSize - bytes1.size(), '2');
        refTryReadFromAtTwoReads (bytes2, bytes1);

        call (buffer->readAll())
        .willReturn (bytes2 + bytes1);
    }

    void testPeekAndPeekAll()
    {
        // Add some bytes to the read buffer:
        QByteArray bytes ("1234567890");
        refTryReadFromAtOnce (bytes);
        // test peek()
        call (buffer->peek (bytes.count()))
        .willReturn (bytes);
        // test peekAll()
        call (buffer->peekAll())
        .willReturn (bytes);
        // finally read the bytes:
        call (buffer->readAll())
        .willReturn (bytes);
    }

    void refPeekToAndReadTo (const QByteArray &delimiter,
                             const QByteArray &bytes)
    {
        call (buffer->peekTo (delimiter))
        .willReturn (bytes);

        call (buffer->readTo (delimiter))
        .willReturn (bytes);
    }

    void testPeekToAndReadTo()
    {
        QByteArray bytes ("1234567890cc12");
        refTryReadFromAtOnce (bytes);
        refPeekToAndReadTo ("cc", bytes.left (12));
        refReadBytesSucceeds (bytes.right (2)); // Just reads the rest.
    }

    void testPeekToAndReadToWhenSeparatorInTwoChunks()
    {
        QByteArray bytes1 (5, '1');
        refTryReadFromAtOnce (bytes1);
        refReadBytesSucceeds (bytes1);
        // Let us put in the buffer an array full of '2's separated by "cc",
        // which is itself split at the buffer end.
        QByteArray bytes2 (ReadBufferSize - bytes1.size() - 1, '2');
        QByteArray bytes3 (bytes1.size() - 1, '2');
        refTryReadFromAtTwoReads (bytes2 + "c", "c" + bytes3);
        // Now the actual test:
        refPeekToAndReadTo ("cc", bytes2 + "cc");
        refReadBytesSucceeds (bytes3); // Just reads the rest.
    }

    void refCanRead (int count, bool canRead)
    {
        call (buffer->canRead (count))
        .willReturn (canRead);
    }

    void testCanRead()
    {
        // The read buffer is initially empty:
        refCanRead (0, true);
        refCanRead (1, false);
        refCanRead (ReadBufferSize, false);
        // Fill the read buffer:
        refTryReadFromAtOnce (QByteArray (ReadBufferSize, '0'));
        refCanRead (0, true);
        refCanRead (1, true);
        refCanRead (ReadBufferSize, true);
        refCanRead (ReadBufferSize + 1, false);
    }

    void refCanWrite (int count, bool canWrite)
    {
        call (buffer->canWrite (count))
        .willReturn (canWrite);
    }

    void testCanWrite()
    {
        refCanWrite (0, true);
        refCanWrite (1, true);
        refCanWrite (10, true);
        refCanWrite (ReadBufferSize, true);
        refCanWrite (ReadBufferSize + 1, false);
        // Fill the write ead buffer but leave a single byte free.
        refWriteBytesSucceeds (QByteArray (ReadBufferSize - 1, '0'));
        refCanWrite (0, true);
        refCanWrite (1, true);
        refCanWrite (2, false);
        // Fill the write buffer completely.
        refWriteBytesSucceeds (QByteArray (1, '1'));
        refCanWrite (0, true);
        refCanWrite (1, false);
    }

    void testPeekAtMostThenReadAtMost()
    {
        QByteArray bytes (ReadBufferSize / 2, '1');
        refTryReadFromAtOnce (bytes);

        call (buffer->peekAtMost (ReadBufferSize))
        .willReturn (bytes);

        call (buffer->readAtMost (ReadBufferSize))
        .willReturn (bytes);

        refCanRead (0, true);
        refCanRead (1, false);
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION (TcpSocketBufferTest);

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

Copyright © 2006 Peter Dimov.
Powered by Doxygen.