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 "../Extensions/QueryExtension.h"
#include "../Extensions/QueryHitsExtension.h"
#include "Imports.cpp"

namespace Protocols {
namespace Gnutella {
namespace Packets {
namespace Testing {

class BinaryReaderTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (BinaryReaderTest);
    CPPUNIT_TEST (testReadUuid);
    CPPUNIT_TEST (testReadGgepBlockEmpty);
    CPPUNIT_TEST (testReadGgepBlockOneUnknownGgep);
    CPPUNIT_TEST (testReadGgepBlockOneUnknownGgepLongData);
    CPPUNIT_TEST (testReadGgepBlockTwoUnknownGgeps);
    CPPUNIT_TEST (testReadIPv4Address);
    CPPUNIT_TEST (testReadQueryExtensionOneXml);
    CPPUNIT_TEST (testReadQueryExtensionOneHuge);
    CPPUNIT_TEST (testReadQueryExtensionOneGgepBlock);
    CPPUNIT_TEST (testReadQueryExtensionOneUnknown);
    CPPUNIT_TEST (testReadQueryExtensionMixed);
    CPPUNIT_TEST (testReadQueryExtensionHugeZero);
    CPPUNIT_TEST (testReadMinSpeed);
    CPPUNIT_TEST (testReadResultSetOneResultOneUrn);
    CPPUNIT_TEST (testReadResultSetOneResultOneGgepBlock);
    CPPUNIT_TEST (testReadResultSetOneResultOnePlainData);
    CPPUNIT_TEST (testReadResultSetOneResultMixedData);
    CPPUNIT_TEST (testReadResultSetTwoResults);
    CPPUNIT_TEST (testReadQueryHitsDataCheckFlagsAllSet);
    CPPUNIT_TEST (testReadQueryHitsDataCheckFlagsPushNotSet);
    CPPUNIT_TEST (testReadQueryHitsDataCheckFlagsBusyNotSet);
    CPPUNIT_TEST (testReadQueryHitsDataCheckFlagsHaveUploadedNotSet);
    CPPUNIT_TEST (testReadQueryHitsDataCheckFlagsUploadSpeedNotSet);
    CPPUNIT_TEST (testReadQueryHitsDataCheckFlagsGgepNotSet);
    CPPUNIT_TEST (testReadQueryHitsDataCheckFlagsNoneSet);
    CPPUNIT_TEST (testReadQueryHitsDataNoGgepBlockNoXmlData);
    CPPUNIT_TEST (testReadQueryHitsDataXmlData);
    CPPUNIT_TEST (testReadQueryHitsDataGgepBlock);
    CPPUNIT_TEST (testReadQueryHitsDataGgepBlockXmlData);
    CPPUNIT_TEST (testReadQueryHitsDataGgepBlockXmlDataOther);
    CPPUNIT_TEST_SUITE_END();

public:
    void scenarioReadUuid (const QByteArray &rawUuid,
                           uint l, ushort w1, ushort w2, uchar b1, uchar b2,
                           uchar b3, uchar b4, uchar b5, uchar b6, uchar b7,
                           uchar b8)
    {
        QUuid uuid (l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8);
        BinaryReader reader (rawUuid);
        QUuid readUuid = reader.readUuid();
        CPPUNIT_ASSERT (uuid == readUuid);
        CPPUNIT_ASSERT (reader.hasReadAll() && !reader.hasReadPastEnd());
    }

    void testReadUuid()
    {
        scenarioReadUuid (QByteArray ("\x67\xc8\x77\x0b\x44\xf1\x41\x0a"
                                      "\xab\x9a\xf9\xb5\x44\x6f\x13\xee", 16),
                          0x67c8770b, 0x44f1, 0x410a,
                          0xab, 0x9a, 0xf9, 0xb5, 0x44, 0x6f, 0x13, 0xee);
        scenarioReadUuid (QByteArray ("\x00\x00\x11\x11\xff\xff\xaa\xaa"
                                      "\xab\xab\xf9\xb5\x44\x00\xee\xff", 16),
                          0x00001111, 0xffff, 0xaaaa,
                          0xab, 0xab, 0xf9, 0xb5, 0x44, 0x00, 0xee, 0xff);
        scenarioReadUuid (QByteArray ("\x11\x11\x11\x11\x33\x33\x55\x55"
                                      "\xee\xff\x22\x44\x66\x88\x00\xcc", 16),
                          0x11111111, 0x3333, 0x5555,
                          0xee, 0xff, 0x22, 0x44, 0x66, 0x88, 0x00, 0xcc);
    }

    void scenarioReadGgepBlock (QByteArray rawGgepBlock,
                                const GgepBlock &block)
    {
        BinaryReader reader (rawGgepBlock);
        GgepBlock readBlock = reader.readGgepBlock();
        CPPUNIT_ASSERT (block == readBlock);
        CPPUNIT_ASSERT (reader.hasReadAll() && !reader.hasReadPastEnd());
    }

    void testReadGgepBlockEmpty()
    {
        scenarioReadGgepBlock (QByteArray(), GgepBlock());
    }

    void testReadGgepBlockOneUnknownGgep()
    {
        QByteArray id ("UNKN");
        QByteArray data ("fortest");
        // Manually build raw data.
        QByteArray rawBytes;
        // GGEP magic byte:
        rawBytes.append (static_cast <char> (0xC3));
        // First extension header:
        rawBytes.append (Ggep::LastExtension | id.length()); // flags
        rawBytes.append (id); // id
        rawBytes.append (0x40 | data.length()); // datalength
        // First extension data:
        rawBytes.append (data);
        // Prepare the block that should be read.
        GgepBlock block;
        block.addExtension (Ggeps::Unknown (id, data));
        scenarioReadGgepBlock (rawBytes, block);
    }

    void testReadGgepBlockOneUnknownGgepLongData()
    {
        QByteArray id ("UNKN");
        QByteArray data (64, '1');
        // Manually build raw data.
        QByteArray rawBytes;
        // GGEP magic byte:
        rawBytes.append (static_cast <char> (0xC3));
        // First extension header:
        rawBytes.append (Ggep::LastExtension | id.length());        // flags
        rawBytes.append (id);                                       // id
        // 2 bytes data length:
        rawBytes.append (static_cast <char> (0x80 | (64 >> 6)));
        rawBytes.append (static_cast <char> (0x40 | (64 & 0x3F)));
        // First extension data:
        rawBytes.append (data);
        // Prepare the block that should be read.
        GgepBlock block;
        block.addExtension (Ggeps::Unknown (id, data));
        scenarioReadGgepBlock (rawBytes, block);
    }

    void testReadGgepBlockTwoUnknownGgeps()
    {
        QByteArray id1 ("UNKN");
        QByteArray data1 ("fortest");
        QByteArray id2 ("unkn");
        QByteArray data2 ("fortest2");
        // Manually build raw data.
        QByteArray rawBytes;
        // GGEP magic byte:
        rawBytes.append (static_cast <char> (0xC3));
        // First extension header:
        rawBytes.append (id1.length()); // flags
        rawBytes.append (id1); // id
        rawBytes.append (0x40 | data1.length()); // datalength
        // First extension data:
        rawBytes.append (data1);
        // Second extension header:
        rawBytes.append (Ggep::LastExtension | id2.length()); // flags
        rawBytes.append (id2); // id
        rawBytes.append (0x40 | data2.length()); // datalength
        // Second extension data:
        rawBytes.append (data2);
        // Prepare the block that should be read.
        GgepBlock block;
        block.addExtension (Ggeps::Unknown (id1, data1));
        block.addExtension (Ggeps::Unknown (id2, data2));
        scenarioReadGgepBlock (rawBytes, block);
    }

    void scenarioReadIPv4Address (quint32 address)
    {
        QByteArray  rawBytes;
        uchar       byte;
        // BigEndian
        rawBytes.append (byte = (address & 0xff000000) >> 24);
        rawBytes.append (byte = (address & 0x00ff0000) >> 16);
        rawBytes.append (byte = (address & 0x0000ff00) >> 8);
        rawBytes.append (byte = address & 0x000000ff);
        BinaryReader    reader (rawBytes);
        CPPUNIT_ASSERT (reader.readIPv4Address().toIPv4Address() == address);
        CPPUNIT_ASSERT (reader.hasReadAll() && !reader.hasReadPastEnd());
    }
    // Maybe I should make several func to 1 scenario each, but I'm not sure
    // how to deal with it.
    void testReadIPv4Address ()
    {
        scenarioReadIPv4Address (0x7f000001);   // 127.0.0.1
        scenarioReadIPv4Address (0xc0a80148);   // 192.168.1.72
        scenarioReadIPv4Address (0x55d63cb9);   // 85.214.60.185
        scenarioReadIPv4Address (0x00000000);   // 0.0.0.0
    }

    void scenarioReadQueryExtension(QByteArray rawBytes,
                                    const QueryData &extension)
    {
        BinaryReader reader (rawBytes);
        CPPUNIT_ASSERT (reader.readQueryData() == extension);
        CPPUNIT_ASSERT (reader.hasReadAll() && !reader.hasReadPastEnd());
    }

    void testReadQueryExtensionOneXml()
    {
        QueryData       extension;
        extension.xmlList += QByteArray ("<xmltest/>");
        scenarioReadQueryExtension (QByteArray ("<xmltest/>"), extension);
    }

    void testReadQueryExtensionOneHuge()
    {
        QueryData       extension;
        extension.urnList += QByteArray ("urn: hugetest");
        scenarioReadQueryExtension (QByteArray ("urn: hugetest"), extension);
    }

    void testReadQueryExtensionOneUnknown()
    {
        QueryData       extension;
        extension.unknownList += QByteArray ("dunnotest");
        scenarioReadQueryExtension (QByteArray ("dunnotest"), extension);
    }

    void testReadQueryExtensionOneGgepBlock()
    {
        QueryData       extension;
        extension.ggepBlock =  GgepBlock().addExtension (Ggeps::Unknown ("UNKN", "fortest"));
        scenarioReadQueryExtension (QByteArray ("\xC3\x84UNKN\107fortest", 14), extension);
    }

    void testReadQueryExtensionMixed()
    {
        QueryData       extension;
        extension.xmlList += QByteArray ("<xmltest/>");
        extension.xmlList += QByteArray ("{xmltest2/}");
        extension.urnList  += QByteArray ("urn: hugetest");
        extension.unknownList  += QByteArray ("dunnotest");
        extension.ggepBlock = GgepBlock().addExtension (Ggeps::Unknown ("UNKN", "fortest"));
        scenarioReadQueryExtension (QByteArray ("<xmltest/>\x1c\144unnotest\x1curn: hugetest\x1c{xmltest2/}\x1c\xC3\x84UNKN\107fortest"), extension);
    }

    void testReadQueryExtensionHugeZero()
    {
        QueryData       extension;
        extension.urnList += QByteArray ("urn: hugetest");
        scenarioReadQueryExtension (QByteArray ("urn: hugetest\0", 14), extension);
    }

    void scenarioReadMinSpeed(bool f1,bool f2,bool f3,bool f4,bool f5,bool f6, uchar byte)
    {
        QByteArray  rawBytes;
        uchar flags = 0x80;
        if(f2) flags |= 0x40;
        if(f3) flags |= 0x20;
        if(f4) flags |= 0x10;
        if(f5) flags |= 0x08;
        if(f6) flags |= 0x04;
        rawBytes.append (flags);
        rawBytes.append (byte);
        BinaryReader reader (rawBytes);
        if(f1)
            CPPUNIT_ASSERT (reader.readMinSpeed() == MinSpeed (f1,f2,f3,f4,f5,f6,byte));
        else
            CPPUNIT_ASSERT (reader.readMinSpeed() == MinSpeed());
        CPPUNIT_ASSERT (reader.hasReadAll() && !reader.hasReadPastEnd());
    }

    void testReadMinSpeed()
    {
        scenarioReadMinSpeed (true, true, true, true, true, true, '\110');
        scenarioReadMinSpeed (true, true, true, true, true, false, '\110');
        scenarioReadMinSpeed (true, true, true, true, false, false, '\110');
        scenarioReadMinSpeed (true, true, true, false, false, false, '\110');
        scenarioReadMinSpeed (true, true, false, false, false, false, '\110');
        scenarioReadMinSpeed (true, false, false, false, false, false, '\110');
    }

    void scenarioReadResultSet(const ResultData &resultData,
                               const QByteArray &bytes, int number)
    {
        QByteArray rawBytes ("\x11\x22\x33\x44\x33\x44\x55\x66TAOCP\0",14);
        rawBytes.append (bytes);
        ResultSet rs;
        Result result;
        result.fileIndex = 0x44332211;
        result.fileSize = 0x66554433;
        result.fullFileName = "TAOCP";
        result.resultData = resultData;
        for(int i=0;i<number;++i)
            rs.append (result);
        for(int i=0;i<number-1;++i)
            rawBytes.append (rawBytes);
        BinaryReader reader (rawBytes);
        CPPUNIT_ASSERT (rs == reader.readQueryHitsResultSet(number));
        CPPUNIT_ASSERT (reader.hasReadAll() && !reader.hasReadPastEnd());
    }

    void testReadResultSetOneResultOneUrn()
    {
        ResultData resultData;
        resultData.urnList.append ("urn:test");
        QByteArray rawBytes ("urn:test\0", 9);
        scenarioReadResultSet (resultData, rawBytes, 1);
    }
    void testReadResultSetOneResultOneGgepBlock()
    {
        ResultData resultData;
        resultData.ggepBlock = GgepBlock().addExtension (Ggeps::Unknown ("UNKN", "fortest"));
        QByteArray rawBytes ("\xC3\x84UNKN\107fortest\0", 15);
        scenarioReadResultSet (resultData, rawBytes, 1);
    }
    void testReadResultSetOneResultOnePlainData()
    {
        ResultData resultData;
        resultData.unknownList.append ("plain:test");
        QByteArray rawBytes ("plain:test\0", 11);
        scenarioReadResultSet (resultData, rawBytes, 1);
    }
    void testReadResultSetOneResultMixedData()
    {
        ResultData resultData;
        resultData.unknownList.append ("plain:test");
        resultData.ggepBlock = GgepBlock().addExtension (Ggeps::Unknown ("UNKN", "fortest"));
        resultData.urnList.append ("urn:test");
        resultData.xmlList.append ("<book></book>");
        QByteArray rawBytes ("plain:test\x1curn:test\x1c<book></book>\x1c\xC3\x84UNKN\107fortest\0", 49);
        scenarioReadResultSet (resultData, rawBytes, 1);
    }
    void testReadResultSetTwoResults()
    {
        scenarioReadResultSet (ResultData(), QByteArray("\0", 1), 2);
    }

    void scenarioReadQueryHitsDataCheckFlags (bool ggep, bool uploadSpeed,
                                              bool haveUploaded, bool busy,
                                              bool push, const char flags[2])
    {
        QueryHitsData hitsData;
        if (ggep)
            hitsData.ggepBlock.addExtension (Ggeps::Unknown ("UNKN", "fortest"));
        hitsData.flagUploadSpeed = uploadSpeed;
        hitsData.flagHaveUploaded = haveUploaded;
        hitsData.flagBusy = busy;
        hitsData.flagPush = push;

        QByteArray rawBytes = hitsData.vendorCode.toBytes();
        rawBytes += "\x02"; // Only flags in open vendor area.
        rawBytes += flags; // The two bytes of flags.
        if (ggep) // GGEP block bytes if any.
            rawBytes += QByteArray ("\xC3\x84UNKN\107fortest");
        rawBytes += QByteArray (16, '\0'); // Null serventId.

        BinaryReader reader (rawBytes);
        QueryHitsData readHitsData = reader.readQueryHitsData();

        CPPUNIT_ASSERT (hitsData == readHitsData);
    }

    void testReadQueryHitsDataCheckFlagsAllSet()
    {
        scenarioReadQueryHitsDataCheckFlags (true, true, true, true, true,
                                             "\x3d\x3d");
    }

    void testReadQueryHitsDataCheckFlagsPushNotSet()
    {
        scenarioReadQueryHitsDataCheckFlags (true, true, true, true, false,
                                             "\x3c\x3d");
    }

    void testReadQueryHitsDataCheckFlagsBusyNotSet()
    {
        scenarioReadQueryHitsDataCheckFlags (true, true, true, false, true,
                                             "\x3d\x39");
    }

    void testReadQueryHitsDataCheckFlagsHaveUploadedNotSet()
    {
        scenarioReadQueryHitsDataCheckFlags (true, true, false, true, true,
                                             "\x3d\x35");
    }

    void testReadQueryHitsDataCheckFlagsUploadSpeedNotSet()
    {
        scenarioReadQueryHitsDataCheckFlags (true, false, true, true, true,
                                             "\x3d\x2d");
    }

    void testReadQueryHitsDataCheckFlagsGgepNotSet()
    {
        scenarioReadQueryHitsDataCheckFlags (false, true, true, true, true,
                                             "\x3d\x1d");
    }

    void testReadQueryHitsDataCheckFlagsNoneSet()
    {
        scenarioReadQueryHitsDataCheckFlags (false, false, false, false, false,
                                             "\x3c\x01");
    }

    void scenarioReadQueryHitsData(QueryHitsData &hitsData,QByteArray &bytes)
    {
        //hitsData.vendorCode   =   VendorCode();
        hitsData.flagUploadSpeed = false;
        hitsData.flagHaveUploaded = false;
        hitsData.flagBusy = false;
        hitsData.flagPush = false;
        hitsData.serventId  =   QUuid (0x11111111, 0x3333, 0x5555, 0xee, 0xff,
                                 0x22, 0x44, 0x66, 0x88, 0x00, 0xcc);
        QByteArray rawBytes ("\x11\x11\x11\x11\x33\x33\x55\x55\xee\xff\x22\x44\x66\x88\0\xcc", 16);
        bytes.append (rawBytes);
        BinaryReader reader (bytes);
        CPPUNIT_ASSERT (hitsData == reader.readQueryHitsData());
        CPPUNIT_ASSERT (reader.hasReadAll() && !reader.hasReadPastEnd());
    }

    void testReadQueryHitsDataNoQHD()
    {
        // all other fields that have not been set.
    }

    void testReadQueryHitsDataNoGgepBlockNoXmlData()
    {
        QueryHitsData hitsData;
        QByteArray rawBytes ("UNKN\x02\x20\x0", 7);
        scenarioReadQueryHitsData (hitsData, rawBytes);
    }

    void testReadQueryHitsDataXmlData()
    {
        QueryHitsData hitsData;
        hitsData.xmlData = QByteArray("<xmltest/>");
        QByteArray rawBytes ("UNKN\x04\x20\x0\xb\x0<xmltest/>\0", 20);
        scenarioReadQueryHitsData (hitsData, rawBytes);
    }
    void testReadQueryHitsDataGgepBlock()
    {
        QueryHitsData hitsData;
        hitsData.ggepBlock = GgepBlock().addExtension (Ggeps::Unknown ("UNKN", "fortest"));
        QByteArray rawBytes ("UNKN\x02\x20\x20\xC3\x84UNKN\107fortest", 21);
        scenarioReadQueryHitsData (hitsData, rawBytes);
    }
    void testReadQueryHitsDataGgepBlockXmlData()
    {
        QueryHitsData hitsData;
        hitsData.xmlData = QByteArray("<xmltest/>");
        hitsData.ggepBlock = GgepBlock().addExtension (Ggeps::Unknown ("UNKN", "fortest"));
        QByteArray rawBytes ("UNKN\x04\x20\x20\xb\x0\xC3\x84UNKN\107fortest<xmltest/>\0", 34);
        scenarioReadQueryHitsData (hitsData, rawBytes);
    }
    void testReadQueryHitsDataGgepBlockXmlDataOther()
    {
        QueryHitsData hitsData;
        hitsData.privateVendor.append(QByteArray("vendor1"));
        hitsData.privateVendor.append(QByteArray("vendor2"));
        hitsData.xmlData = QByteArray("<xmltest/>");
        hitsData.ggepBlock = GgepBlock().addExtension (Ggeps::Unknown ("UNKN", "fortest"));
        QByteArray rawBytes ("UNKN\x04\x20\x20\xb\x0vendor1\xC3\x84UNKN\107fortestvendor2<xmltest/>\0", 48);
        scenarioReadQueryHitsData (hitsData, rawBytes);
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION(BinaryReaderTest);

} // namespace Testing
} // namespace Packets
} // namespace Gnutella
} // namespace Protocols

Copyright © 2006 Peter Dimov.
Powered by Doxygen.