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

namespace Utils {
namespace Encodings {

class BinaryReaderTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE(BinaryReaderTest);
    CPPUNIT_TEST(testCtors);
    CPPUNIT_TEST(testSetProperties);
    CPPUNIT_TEST(testReadInts);
    CPPUNIT_TEST(testReadBytes);
    CPPUNIT_TEST(testReadStrings);
    CPPUNIT_TEST(testReadPastEnd);
    CPPUNIT_TEST_SUITE_END();

public:
    void setUp()
    {
    }

    void tearDown()
    {
    }

    void testCtors()
    {
        QByteArray emptyBuffer;
        {
            BinaryReader reader (emptyBuffer, BinaryReader::LittleEndian);
            CPPUNIT_ASSERT (BinaryReader::LittleEndian == reader.byteOrder());
            CPPUNIT_ASSERT (BinaryReader::ReadFromStart == reader.readOrigin());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (!reader.hasReadPastEnd());
        }
        {
            BinaryReader reader (emptyBuffer, BinaryReader::BigEndian);
            CPPUNIT_ASSERT (BinaryReader::BigEndian == reader.byteOrder());
            CPPUNIT_ASSERT (BinaryReader::ReadFromStart == reader.readOrigin());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (!reader.hasReadPastEnd());
            CPPUNIT_ASSERT (reader.canRead(0));
            CPPUNIT_ASSERT (!reader.canRead(1));

        }
        QByteArray nonEmtpyBuffer (4, '\0');
        {
            BinaryReader reader (nonEmtpyBuffer, BinaryReader::LittleEndian);
            CPPUNIT_ASSERT (!reader.hasReadAll());
            CPPUNIT_ASSERT (!reader.hasReadPastEnd());
            CPPUNIT_ASSERT (reader.canRead(0));
            CPPUNIT_ASSERT (reader.canRead(1));
            CPPUNIT_ASSERT (reader.canRead(2));
            CPPUNIT_ASSERT (reader.canRead(4));
            CPPUNIT_ASSERT (!reader.canRead(5));
        }
    }

    void testSetProperties()
    {
        QByteArray emptyBuffer;
        BinaryReader reader (emptyBuffer, BinaryReader::LittleEndian);
        // Test byte order:
        reader.setByteOrder (BinaryReader::BigEndian);
        CPPUNIT_ASSERT (BinaryReader::BigEndian == reader.byteOrder());
        reader.setByteOrder (BinaryReader::LittleEndian);
        CPPUNIT_ASSERT (BinaryReader::LittleEndian == reader.byteOrder());
        // Test read origin:
        reader.setReadOrigin (BinaryReader::ReadFromEnd);
        CPPUNIT_ASSERT (BinaryReader::ReadFromEnd == reader.readOrigin());
        reader.setReadOrigin (BinaryReader::ReadFromStart);
        CPPUNIT_ASSERT (BinaryReader::ReadFromStart == reader.readOrigin());
    }

    void testReadInts()
    {
        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 reading form start:
            BinaryReader reader (buffer, BinaryReader::LittleEndian);
            CPPUNIT_ASSERT (0x0100 == reader.readUInt16());
            CPPUNIT_ASSERT (0x0302 == reader.readInt16());
            CPPUNIT_ASSERT (0x04   == reader.lookAhead(1));
            CPPUNIT_ASSERT (0x05   == reader.lookAhead(2));
            CPPUNIT_ASSERT (0x0D   == reader.lookAhead(10));
            CPPUNIT_ASSERT (reader.canRead(24));
            CPPUNIT_ASSERT (0x1B   == reader.lookAhead(24));
            CPPUNIT_ASSERT (!reader.canRead(25));
            CPPUNIT_ASSERT (0x00   == reader.lookAhead(25));
            CPPUNIT_ASSERT (0x07060504 == reader.readUInt32());
            CPPUNIT_ASSERT (0x0B0A0908 == reader.readInt32());
            CPPUNIT_ASSERT (Q_INT64_C (0x131211100F0E0D0C) == reader.readUInt64());
            CPPUNIT_ASSERT (Q_INT64_C (0x1B1A191817161514) == reader.readInt64());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (!reader.hasReadPastEnd());
            // Try reading past end:
            CPPUNIT_ASSERT (0 == reader.readUInt16());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
        { // Test big endian reading from start:
            BinaryReader reader (buffer, BinaryReader::BigEndian);
            CPPUNIT_ASSERT (0x0001 == reader.readUInt16());
            CPPUNIT_ASSERT (0x0203 == reader.readInt16());
            CPPUNIT_ASSERT (0x04   == reader.lookAhead(1));
            CPPUNIT_ASSERT (0x05   == reader.lookAhead(2));
            CPPUNIT_ASSERT (0x0D   == reader.lookAhead(10));
            CPPUNIT_ASSERT (0x04050607 == reader.readUInt32());
            CPPUNIT_ASSERT (0x08090A0B == reader.readInt32());
            CPPUNIT_ASSERT (Q_INT64_C (0x0C0D0E0F10111213) == reader.readUInt64());
            CPPUNIT_ASSERT (Q_INT64_C (0x1415161718191A1B) == reader.readInt64());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (!reader.hasReadPastEnd());
            // Try reading past end:
            CPPUNIT_ASSERT (0 == reader.readUInt16());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
        { // Test little endian reading from end:
            BinaryReader reader (buffer, BinaryReader::LittleEndian);
            reader.setReadOrigin (BinaryReader::ReadFromEnd);
            CPPUNIT_ASSERT (Q_INT64_C (0x1B1A191817161514) == reader.readInt64());
            CPPUNIT_ASSERT (Q_INT64_C (0x131211100F0E0D0C) == reader.readUInt64());
            CPPUNIT_ASSERT (0x0B   == reader.lookAhead(1));
            CPPUNIT_ASSERT (0x0A   == reader.lookAhead(2));
            CPPUNIT_ASSERT (0x02   == reader.lookAhead(10));
            CPPUNIT_ASSERT (0x0B0A0908 == reader.readInt32());
            CPPUNIT_ASSERT (0x07060504 == reader.readUInt32());
            CPPUNIT_ASSERT (0x0302 == reader.readInt16());
            CPPUNIT_ASSERT (0x0100 == reader.readUInt16());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (!reader.hasReadPastEnd());
            // Try reading past end:
            CPPUNIT_ASSERT (0 == reader.readUInt16());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
        { // Test big endian readinf from end:
            BinaryReader reader (buffer, BinaryReader::BigEndian);
            reader.setReadOrigin (BinaryReader::ReadFromEnd);
            CPPUNIT_ASSERT (Q_INT64_C (0x1415161718191A1B) == reader.readInt64());
            CPPUNIT_ASSERT (Q_INT64_C (0x0C0D0E0F10111213) == reader.readUInt64());
            CPPUNIT_ASSERT (0x0B   == reader.lookAhead(1));
            CPPUNIT_ASSERT (0x0A   == reader.lookAhead(2));
            CPPUNIT_ASSERT (0x02   == reader.lookAhead(10));
            CPPUNIT_ASSERT (0x00   == reader.lookAhead(12));
            CPPUNIT_ASSERT (0x00   == reader.lookAhead(13));
            CPPUNIT_ASSERT (0x08090A0B == reader.readInt32());
            CPPUNIT_ASSERT (0x04050607 == reader.readUInt32());
            CPPUNIT_ASSERT (0x0203 == reader.readInt16());
            CPPUNIT_ASSERT (0x0001 == reader.readUInt16());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (!reader.hasReadPastEnd());
            // Try reading past end:
            CPPUNIT_ASSERT (0 == reader.readUInt16());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
    }

    void testReadBytes()
    {
        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, read from start:
            BinaryReader reader (buffer, BinaryReader::BigEndian);
            // default read origin MUST be from start
            // read single byte:
            CPPUNIT_ASSERT (0x00 == reader.readByte());
            // read multiple bytes:
            QByteArray readBytes = reader.readBytes (7);
            CPPUNIT_ASSERT (readBytes.size() == 7);
            CPPUNIT_ASSERT (memcmp (rawData + 1, readBytes.constData(), 7) == 0);
            // read zero bytes:
            readBytes = reader.readBytes (0);
            CPPUNIT_ASSERT (readBytes.size() == 0);
            // read the last byte:
            CPPUNIT_ASSERT (0x08 == reader.readByte());
            // Make sure all was read and not past end:
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (!reader.hasReadPastEnd());
            // Try reading past end:
            readBytes = reader.readBytes (6);
            CPPUNIT_ASSERT (6 == readBytes.size());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
        { // Try the exact same test with little endian, read from start:
            BinaryReader reader (buffer, BinaryReader::LittleEndian);
            // read single byte:
            CPPUNIT_ASSERT (0x00 == reader.readByte());
            // read multiple bytes:
            QByteArray readBytes = reader.readBytes (7);
            CPPUNIT_ASSERT (readBytes.size() == 7);
            CPPUNIT_ASSERT (memcmp (rawData + 1, readBytes.constData(), 7) == 0);
            // read zero bytes:
            readBytes = reader.readBytes (0);
            CPPUNIT_ASSERT (readBytes.size() == 0);
            // read the last byte:
            CPPUNIT_ASSERT (0x08 == reader.readByte());
            // Make sure all was read and not past end:
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (!reader.hasReadPastEnd());
            // Try reading past end:
            readBytes = reader.readBytes (6);
            CPPUNIT_ASSERT (6 == readBytes.size());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
        { // Try with big endian, read from start:
            BinaryReader reader (buffer, BinaryReader::BigEndian);
            reader.setReadOrigin (BinaryReader::ReadFromEnd);
            // read single byte:
            CPPUNIT_ASSERT (0x08 == reader.readByte());
            // read multiple bytes:
            QByteArray readBytes = reader.readBytes (7);
            CPPUNIT_ASSERT (readBytes.size() == 7);
            CPPUNIT_ASSERT (memcmp (rawData + 1, readBytes.constData(), 7) == 0);
            // read zero bytes:
            readBytes = reader.readBytes (0);
            CPPUNIT_ASSERT (readBytes.size() == 0);
            // read the last byte:
            CPPUNIT_ASSERT (0x00 == reader.readByte());
            // Make sure all was read and not past end:
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (!reader.hasReadPastEnd());
            // Try reading past end:
            readBytes = reader.readBytes (6);
            CPPUNIT_ASSERT (6 == readBytes.size());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
        { // Try the exact same test with little endian, read from start:
            BinaryReader reader (buffer, BinaryReader::LittleEndian);
            reader.setReadOrigin (BinaryReader::ReadFromEnd);
            // read single byte:
            CPPUNIT_ASSERT (0x08 == reader.readByte());
            // read multiple bytes:
            QByteArray readBytes = reader.readBytes (7);
            CPPUNIT_ASSERT (readBytes.size() == 7);
            CPPUNIT_ASSERT (memcmp (rawData + 1, readBytes.constData(), 7) == 0);
            // read zero bytes:
            readBytes = reader.readBytes (0);
            CPPUNIT_ASSERT (0 == readBytes.size());
            // read the last byte:
            CPPUNIT_ASSERT (0x00 == reader.readByte());
            // Make sure all was read and not past end:
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (!reader.hasReadPastEnd());
            // Try reading past end:
            readBytes = reader.readBytes (6);
            CPPUNIT_ASSERT (6 == readBytes.size());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
        {
            BinaryReader reader (buffer, BinaryReader::BigEndian);
            CPPUNIT_ASSERT (buffer == reader.readAll());
            // Should not be able to read all bytes again:
            CPPUNIT_ASSERT (QByteArray() == reader.readAll());
        }
    }

    void testReadStrings()
    {
        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, from start:
            BinaryReader reader (buffer, BinaryReader::LittleEndian);
            QByteArray string = reader.readString();
            CPPUNIT_ASSERT (0 == string.length());
            string = reader.readString();
            CPPUNIT_ASSERT (string == "non empty");
            string = reader.readString();
            CPPUNIT_ASSERT (0 == string.length());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (!reader.hasReadPastEnd());
            // Try read past end:
            string = reader.readString();
            CPPUNIT_ASSERT (0 == string.length());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
        { // Big endian, from start:
            BinaryReader reader (buffer, BinaryReader::BigEndian);
            QByteArray string = reader.readString();
            CPPUNIT_ASSERT (0 == string.length());
            string = reader.readString();
            CPPUNIT_ASSERT (string == "non empty");
            string = reader.readString();
            CPPUNIT_ASSERT (0 == string.length());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (!reader.hasReadPastEnd());
            // Try read past end:
            string = reader.readString();
            CPPUNIT_ASSERT (0 == string.length());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
        { // Little endian, from end:
            BinaryReader reader (buffer, BinaryReader::LittleEndian);
            reader.setReadOrigin (BinaryReader::ReadFromEnd);
            QByteArray string = reader.readString();
            CPPUNIT_ASSERT (0 == string.length());
            string = reader.readString();
            CPPUNIT_ASSERT (0 == string.length());
            string = reader.readString();
            CPPUNIT_ASSERT (string == "non empty");
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (!reader.hasReadPastEnd());
            // Try read past end:
            string = reader.readString();
            CPPUNIT_ASSERT (0 == string.length());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
        { // Big endian, from end:
            BinaryReader reader (buffer, BinaryReader::BigEndian);
            reader.setReadOrigin (BinaryReader::ReadFromEnd);
            QByteArray string = reader.readString();
            CPPUNIT_ASSERT (0 == string.length());
            string = reader.readString();
            CPPUNIT_ASSERT (0 == string.length());
            string = reader.readString();
            CPPUNIT_ASSERT (string == "non empty");
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (!reader.hasReadPastEnd());
            // Try read past end:
            string = reader.readString();
            CPPUNIT_ASSERT (0 == string.length());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
    }

    void testReadPastEnd()
    {
        // We already tested reading past the end after the complete buffer
        // was read 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 (rawData, sizeof (rawData));
        {
            BinaryReader reader (buffer, BinaryReader::LittleEndian);
            reader.readBytes (7);
            CPPUNIT_ASSERT (0 == reader.readUInt16());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
        {
            BinaryReader reader (buffer, BinaryReader::LittleEndian);
            reader.readBytes (7);
            CPPUNIT_ASSERT (0 == reader.readInt16());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
        {
            BinaryReader reader (buffer, BinaryReader::LittleEndian);
            reader.readBytes (7);
            CPPUNIT_ASSERT (0 == reader.readUInt32());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
        {
            BinaryReader reader (buffer, BinaryReader::LittleEndian);
            reader.readBytes (7);
            CPPUNIT_ASSERT (0 == reader.readInt32());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
        {
            BinaryReader reader (buffer, BinaryReader::LittleEndian);
            reader.readBytes (7);
            CPPUNIT_ASSERT (0 == reader.readUInt64());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
        {
            BinaryReader reader (buffer, BinaryReader::LittleEndian);
            reader.readBytes (7);
            CPPUNIT_ASSERT (0 == reader.readInt64());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
        {
            BinaryReader reader (buffer, BinaryReader::LittleEndian);
            reader.readBytes (7);
            QByteArray readBytes = reader.readBytes (4);
            CPPUNIT_ASSERT (4 == readBytes.size());
            CPPUNIT_ASSERT (reader.hasReadAll());
            CPPUNIT_ASSERT (reader.hasReadPastEnd());
        }
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION(BinaryReaderTest);

} // namespace Codings
} // namespace Utils

Copyright © 2006 Peter Dimov.
Powered by Doxygen.