BinaryWriterTest.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 "../BinaryWriter.h"
#include "cppunit/extensions/HelperMacros.h"

namespace Utils {
namespace Encodings {


class BinaryWriterTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE(BinaryWriterTest);
    CPPUNIT_TEST(testCtors);
    CPPUNIT_TEST(testSetProperties);
    CPPUNIT_TEST(testWriteInts);
    CPPUNIT_TEST(testWriteBytes);
    CPPUNIT_TEST(testWriteStrings);
    CPPUNIT_TEST(testWritePastEnd);
    CPPUNIT_TEST(testReserveOnAutoGrowBuffer);
    CPPUNIT_TEST_SUITE_END();

public:
    void setUp()
    {
    }

    void tearDown()
    {
    }

    void testCtors()
    {
        QByteArray emptyBuffer;
        {
            BinaryWriter writer (&emptyBuffer, BinaryWriter::LittleEndian);
            CPPUNIT_ASSERT (BinaryWriter::LittleEndian == writer.byteOrder());
            CPPUNIT_ASSERT (0 == writer.bytesWritten());
            CPPUNIT_ASSERT (!writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (emptyBuffer == writer.buffer());
        }
        {
            BinaryWriter writer (BinaryWriter::BigEndian);
            CPPUNIT_ASSERT (BinaryWriter::BigEndian == writer.byteOrder());
            CPPUNIT_ASSERT (0 == writer.bytesWritten());
            CPPUNIT_ASSERT (!writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (emptyBuffer == writer.buffer());
        }
        QByteArray nonEmtpyBuffer (4, '\0');
        {
            BinaryWriter writer (&nonEmtpyBuffer, BinaryWriter::LittleEndian);
            CPPUNIT_ASSERT (0 == writer.bytesWritten());
            CPPUNIT_ASSERT (!writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (nonEmtpyBuffer == writer.buffer());
        }
    }

    void testSetProperties()
    {
        BinaryWriter writer (BinaryWriter::LittleEndian);
        // Test byte order:
        writer.setByteOrder (BinaryWriter::BigEndian);
        CPPUNIT_ASSERT (BinaryWriter::BigEndian == writer.byteOrder());
        writer.setByteOrder (BinaryWriter::LittleEndian);
        CPPUNIT_ASSERT (BinaryWriter::LittleEndian == writer.byteOrder());
    }

    void testWriteInts()
    {
        char rawData[] = { 0x00, 0x01,
                           0x02, 0x03,
                           0x04, 0x05, 0x06, 0x07,
                           0x08, 0x09, 0x0A, 0x0B,
                           0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13,
                           0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B };

        QByteArray buffer = QByteArray::fromRawData (rawData, sizeof (rawData));
        { // Test little endian, write in self-allocated growable buffer:
            BinaryWriter writer (BinaryWriter::LittleEndian);
            writer.writeUInt16 (0x0100);
            writer.writeInt16 (0x0302);
            writer.writeUInt32 (0x07060504);
            writer.writeInt32 (0x0B0A0908);
            writer.writeUInt64 (Q_INT64_C (0x131211100F0E0D0C));
            writer.writeInt64 (Q_INT64_C (0x1B1A191817161514));
            CPPUNIT_ASSERT (28 == writer.bytesWritten());
            CPPUNIT_ASSERT (!writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (buffer == writer.buffer());
        }
        { // Test big endian, write in self-allocated growable buffer:
            BinaryWriter writer (BinaryWriter::BigEndian);
            writer.writeUInt16 (0x0001);
            writer.writeInt16 (0x0203);
            writer.writeUInt32 (0x04050607);
            writer.writeInt32 (0x08090A0B);
            writer.writeUInt64 (Q_INT64_C (0x0C0D0E0F10111213));
            writer.writeInt64 (Q_INT64_C (0x1415161718191A1B));
            CPPUNIT_ASSERT (28 == writer.bytesWritten());
            CPPUNIT_ASSERT (!writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (buffer == writer.buffer());
        }
        { // Test little endian, write in a given non-growable buffer:
            QByteArray givenBuffer (28, 0);
            BinaryWriter writer (&givenBuffer, BinaryWriter::LittleEndian);
            writer.writeUInt16 (0x0100);
            writer.writeInt16 (0x0302);
            writer.writeUInt32 (0x07060504);
            writer.writeInt32 (0x0B0A0908);
            writer.writeUInt64 (Q_INT64_C (0x131211100F0E0D0C));
            writer.writeInt64 (Q_INT64_C (0x1B1A191817161514));
            CPPUNIT_ASSERT (28 == writer.bytesWritten());
            CPPUNIT_ASSERT (!writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (buffer == writer.buffer());
            // Now try writing past end:
            writer.writeUInt16 (0x3434);
            CPPUNIT_ASSERT (writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (30 == writer.bytesWritten());
            CPPUNIT_ASSERT (28 == givenBuffer.size()); // Buffer was NOT grown.
        }
        { // Test big endian, write in a given non-growable buffer:
            QByteArray givenBuffer (28, 0);
            BinaryWriter writer (&givenBuffer, BinaryWriter::BigEndian);
            writer.writeUInt16 (0x0001);
            writer.writeInt16 (0x0203);
            writer.writeUInt32 (0x04050607);
            writer.writeInt32 (0x08090A0B);
            writer.writeUInt64 (Q_INT64_C (0x0C0D0E0F10111213));
            writer.writeInt64 (Q_INT64_C (0x1415161718191A1B));
            CPPUNIT_ASSERT (28 == writer.bytesWritten());
            CPPUNIT_ASSERT (!writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (buffer == writer.buffer());
            // Now try writing past end:
            writer.writeUInt16 (0x3434);
            CPPUNIT_ASSERT (writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (30 == writer.bytesWritten());
            CPPUNIT_ASSERT (28 == givenBuffer.size()); // Buffer was NOT grown.
        }
    }

    void testWriteBytes()
    {
        char rawData[] = { 0x00,
                           0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                           0x08 };

        QByteArray buffer = QByteArray::fromRawData (rawData, sizeof (rawData));
        // Byte order MUST NOT matter:
        { // Try with big endian, growable buffer:
            BinaryWriter writer (BinaryWriter::BigEndian);
            // write single byte:
            writer.writeByte (0x00);
            // write multiple bytes:
            QByteArray writeBytes = QByteArray::fromRawData (rawData + 1, 7);
            writer.writeBytes (writeBytes);
            // write zero bytes:
            writer.writeBytes (QByteArray());
            // write the last byte:
            writer.writeByte (0x08);
            // Make sure all was written and not past end:
            CPPUNIT_ASSERT (9 == writer.bytesWritten());
            CPPUNIT_ASSERT (!writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (buffer == writer.buffer());
        }
        { // Try the exact same with little endian, growable buffer:
            BinaryWriter writer (BinaryWriter::LittleEndian);
            // write single byte:
            writer.writeByte (0x00);
            // write multiple bytes:
            QByteArray writeBytes = QByteArray::fromRawData (rawData + 1, 7);
            writer.writeBytes (writeBytes);
            // write zero bytes:
            writer.writeBytes (QByteArray());
            // write the last byte:
            writer.writeByte (0x08);
            // Make sure all was written and not past end:
            CPPUNIT_ASSERT (9 == writer.bytesWritten());
            CPPUNIT_ASSERT (!writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (buffer == writer.buffer());
        }
        { // Try with big endian, given non-growable buffer:
            QByteArray givenBuffer (9, 0);
            BinaryWriter writer (&givenBuffer, BinaryWriter::BigEndian);
            // write single byte:
            writer.writeByte (0x00);
            // write multiple bytes:
            QByteArray writeBytes = QByteArray::fromRawData (rawData + 1, 7);
            writer.writeBytes (writeBytes);
            // write zero bytes:
            writer.writeBytes (QByteArray());
            // write the last byte:
            writer.writeByte (0x08);
            // Make sure all was written and not past end:
            CPPUNIT_ASSERT (9 == writer.bytesWritten());
            CPPUNIT_ASSERT (!writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (buffer == writer.buffer());
            // Try writing past end:
            writer.writeBytes (writeBytes);
            CPPUNIT_ASSERT (16 == writer.bytesWritten());
            CPPUNIT_ASSERT (writer.hasWrittenPastEnd());
        }
        { // Try the exact same with little endian, given non-growable buffer:
            QByteArray givenBuffer (9, 0);
            BinaryWriter writer (&givenBuffer, BinaryWriter::LittleEndian);
            // write single byte:
            writer.writeByte (0x00);
            // write multiple bytes:
            QByteArray writeBytes = QByteArray::fromRawData (rawData + 1, 7);
            writer.writeBytes (writeBytes);
            // write zero bytes:
            writer.writeBytes (QByteArray());
            // write the last byte:
            writer.writeByte (0x08);
            // Make sure all was written and not past end:
            CPPUNIT_ASSERT (9 == writer.bytesWritten());
            CPPUNIT_ASSERT (!writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (buffer == writer.buffer());
            // Try writing past end:
            writer.writeBytes (writeBytes);
            CPPUNIT_ASSERT (16 == writer.bytesWritten());
            CPPUNIT_ASSERT (writer.hasWrittenPastEnd());
        }
    }

    void testWriteStrings()
    {
        char rawData[] = "\0non empty\0"; // One more \0 IS PUT by the compiler!

        QByteArray buffer = QByteArray::fromRawData (rawData, sizeof (rawData));
        // Endianness MUST NOT matter:
        { // Little endian, growable:
            BinaryWriter writer (BinaryWriter::LittleEndian);
            // Write the first empty string:
            writer.writeString (QByteArray());
            // Write "non empty":
            writer.writeString (QByteArray (rawData + 1));
            // Write the last empty string:
            writer.writeString (QByteArray());
            CPPUNIT_ASSERT (sizeof (rawData) == writer.bytesWritten());
            CPPUNIT_ASSERT (!writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (buffer == writer.buffer());
        }
        { // Big endian, growable:
            BinaryWriter writer (BinaryWriter::BigEndian);
            // Write the first empty string:
            writer.writeString (QByteArray());
            // Write "non empty":
            writer.writeString (QByteArray (rawData + 1));
            // Write the last empty string:
            writer.writeString (QByteArray());
            CPPUNIT_ASSERT (sizeof (rawData) == writer.bytesWritten());
            CPPUNIT_ASSERT (!writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (buffer == writer.buffer());
        }
        { // Little endian, non-growable:
            QByteArray givenBuffer (12, 1);
            BinaryWriter writer (&givenBuffer, BinaryWriter::LittleEndian);
            // Write the first empty string:
            writer.writeString (QByteArray());
            // Write "non empty":
            writer.writeString (QByteArray (rawData + 1));
            // Write the last empty string:
            writer.writeString (QByteArray());
            CPPUNIT_ASSERT (sizeof (rawData) == writer.bytesWritten());
            CPPUNIT_ASSERT (!writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (buffer == writer.buffer());
            // Try read past end:
            writer.writeString (QByteArray());
            CPPUNIT_ASSERT (sizeof (rawData) + 1 == writer.bytesWritten());
            CPPUNIT_ASSERT (writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (buffer == writer.buffer());
        }
        { // Big endian, from end:
            QByteArray givenBuffer (12, 1);
            BinaryWriter writer (&givenBuffer, BinaryWriter::BigEndian);
            // Write the first empty string:
            writer.writeString (QByteArray());
            // Write "non empty":
            writer.writeString (QByteArray (rawData + 1));
            // Write the last empty string:
            writer.writeString (QByteArray());
            CPPUNIT_ASSERT (sizeof (rawData) == writer.bytesWritten());
            CPPUNIT_ASSERT (!writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (buffer == writer.buffer());
            // Try read past end:
            writer.writeString (QByteArray());
            CPPUNIT_ASSERT (sizeof (rawData) + 1 == writer.bytesWritten());
            CPPUNIT_ASSERT (writer.hasWrittenPastEnd());
            CPPUNIT_ASSERT (buffer == writer.buffer());
        }
    }

    void testWritePastEnd()
    {
        // We already tested writing past the end after the complete buffer
        // was written completely. Here we will test when half of the integer,
        // for example, is within bounds and the rest is past the bounds.
        char rawData[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
        QByteArray buffer = QByteArray::fromRawData (rawData, sizeof (rawData));
        {
            QByteArray givenBuffer (8, 0);
            BinaryWriter writer (&givenBuffer, BinaryWriter::LittleEndian);
            writer.writeBytes (QByteArray::fromRawData (rawData, 7));
            writer.writeUInt16 (0x1111);
            CPPUNIT_ASSERT (9 == writer.bytesWritten());
            CPPUNIT_ASSERT (writer.hasWrittenPastEnd());
        }
        {
            QByteArray givenBuffer (8, 0);
            BinaryWriter writer (&givenBuffer, BinaryWriter::LittleEndian);
            writer.writeBytes (QByteArray::fromRawData (rawData, 7));
            writer.writeInt16 (0);
            CPPUNIT_ASSERT (9 == writer.bytesWritten());
            CPPUNIT_ASSERT (writer.hasWrittenPastEnd());
        }
        {
            QByteArray givenBuffer (8, 0);
            BinaryWriter writer (&givenBuffer, BinaryWriter::LittleEndian);
            writer.writeBytes (QByteArray::fromRawData (rawData, 7));
            writer.writeUInt32 (0);
            CPPUNIT_ASSERT (11 == writer.bytesWritten());
            CPPUNIT_ASSERT (writer.hasWrittenPastEnd());
        }
        {
            QByteArray givenBuffer (8, 0);
            BinaryWriter writer (&givenBuffer, BinaryWriter::LittleEndian);
            writer.writeBytes (QByteArray::fromRawData (rawData, 7));
            writer.writeInt32 (0);
            CPPUNIT_ASSERT (11 == writer.bytesWritten());
            CPPUNIT_ASSERT (writer.hasWrittenPastEnd());
        }
        {
            QByteArray givenBuffer (8, 0);
            BinaryWriter writer (&givenBuffer, BinaryWriter::LittleEndian);
            writer.writeBytes (QByteArray::fromRawData (rawData, 7));
            writer.writeUInt64 (0);
            CPPUNIT_ASSERT (15 == writer.bytesWritten());
            CPPUNIT_ASSERT (writer.hasWrittenPastEnd());
        }
        {
            QByteArray givenBuffer (8, 0);
            BinaryWriter writer (&givenBuffer, BinaryWriter::LittleEndian);
            writer.writeBytes (QByteArray::fromRawData (rawData, 7));
            writer.writeInt64 (0);
            CPPUNIT_ASSERT (15 == writer.bytesWritten());
            CPPUNIT_ASSERT (writer.hasWrittenPastEnd());
        }
        {
            QByteArray givenBuffer (8, 0);
            BinaryWriter writer (&givenBuffer, BinaryWriter::LittleEndian);
            writer.writeBytes (QByteArray::fromRawData (rawData, 7));
            writer.writeBytes (QByteArray::fromRawData (rawData, 7));
            CPPUNIT_ASSERT (14 == writer.bytesWritten());
            CPPUNIT_ASSERT (writer.hasWrittenPastEnd());
        }
    }

    void testReserveOnAutoGrowBuffer()
    {
        BinaryWriter writer (BinaryWriter::BigEndian, true);
        writer.reserve (10);
        writer.writeUInt64 (0); // write 8 bytes
        CPPUNIT_ASSERT (writer.hasWrittenAll() == false);
        CPPUNIT_ASSERT (writer.hasWrittenPastEnd() == false);
        writer.writeUInt64 (0); // write 8 more => 16 > 10, but no grow, so:
        CPPUNIT_ASSERT (writer.hasWrittenAll() == true);
        CPPUNIT_ASSERT (writer.hasWrittenPastEnd() == true);
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION(BinaryWriterTest);

} // namespace Codings
} // namespace Utils

Copyright © 2006 Peter Dimov.
Powered by Doxygen.