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

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

class BinaryWriterTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE(BinaryWriterTest);
    CPPUNIT_TEST(testWriteGgepBlock);
    CPPUNIT_TEST(testWriteUuid);
    CPPUNIT_TEST(testWriteIPv4Address);
    CPPUNIT_TEST(testWriteQueryDataOneXml);
    CPPUNIT_TEST(testWriteQueryDataOneHuge);
    CPPUNIT_TEST(testWriteQueryDataOneUnknown);
    CPPUNIT_TEST(testWriteQueryDataOneGgepBlock);
    CPPUNIT_TEST(testWriteQueryDataMixed);
    CPPUNIT_TEST(testWriteMinSpeed);
    CPPUNIT_TEST(testWriteResultSetOneResultOneUrn);
    CPPUNIT_TEST(testWriteResultSetOneResultOneGgepBlock);
    CPPUNIT_TEST(testWriteResultSetOneResultOnePlainData);
    CPPUNIT_TEST(testWriteResultSetOneResultMixedData);
    CPPUNIT_TEST(testWriteResultSetTwoResults);
    CPPUNIT_TEST(testWriteQueryHitsDataCheckFlagsAllSet);
    CPPUNIT_TEST(testWriteQueryHitsDataCheckFlagsPushNotSet);
    CPPUNIT_TEST(testWriteQueryHitsDataCheckFlagsBusyNotSet);
    CPPUNIT_TEST(testWriteQueryHitsDataCheckFlagsUploadSpeedNotSet);
    CPPUNIT_TEST(testWriteQueryHitsDataCheckFlagsHaveUploadedNotSet);
    CPPUNIT_TEST(testWriteQueryHitsDataCheckFlagsGgepNotSet);
    CPPUNIT_TEST(testWriteQueryHitsDataCheckFlagsNoneSet);
    CPPUNIT_TEST(testWriteQueryHitsDataNoGgepBlockNoXmlData);
    CPPUNIT_TEST(testWriteQueryHitsDataXmlData);
    CPPUNIT_TEST(testWriteQueryHitsDataGgepBlock);
    CPPUNIT_TEST(testWriteQueryHitsDataGgepBlockXmlData);
    CPPUNIT_TEST(testWriteQueryHitsDataGgepBlockXmlDataOther);
    CPPUNIT_TEST_SUITE_END();

public:
    void scenarioWriteUuid (uint l, ushort w1, ushort w2,
                            uchar b1, uchar b2, uchar b3, uchar b4,
                            uchar b5, uchar b6, uchar b7, uchar b8,
                            const QByteArray &rawUuid)
    {
        QUuid uuid (l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8 );
        BinaryWriter writer;
        writer.writeUuid (uuid);
        CPPUNIT_ASSERT (writer.buffer() == rawUuid);
        CPPUNIT_ASSERT (writer.hasWrittenAll() && !writer.hasWrittenPastEnd());
    }

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

    // the logic is that BinaryReader is right .
    void scenarioWriteGgepBlock (QByteArray id, QByteArray rawData, int flags)
    {
        GgepBlock block;
        Ggeps::Unknown ggep (id, rawData, flags);
        // Write a block containing the same extension four times:
        for(int i = 0; i < 4; ++i)
            block.addExtension(ggep);
        BinaryWriter writer;
        writer.writeGgepBlock(block);
        BinaryReader reader (writer.buffer());
        GgepBlock readBlock = reader.readGgepBlock();
        CPPUNIT_ASSERT (readBlock == block);
        CPPUNIT_ASSERT (reader.hasReadAll() && !reader.hasReadPastEnd());
    }

    void testWriteGgepBlock()
    {
        scenarioWriteGgepBlock ("un", "fortest", 0x40);
        scenarioWriteGgepBlock ("unknown", "Hi , nice to meet you here^_^!", 0x80);
        scenarioWriteGgepBlock ("hehe", QByteArray(), 0x60);
    }

    void scenarioWriteIPv4Address (quint32 address)
    {
        BinaryWriter writer;
        QHostAddress qAddress (address);
        writer.writeIPv4Address (qAddress);
        BinaryReader reader (writer.buffer());
        CPPUNIT_ASSERT (reader.readIPv4Address().toIPv4Address() == address);
        CPPUNIT_ASSERT (reader.hasReadAll() && !reader.hasReadPastEnd());
    }

    void testWriteIPv4Address()
    {
        scenarioWriteIPv4Address (0x7f000001);  // 127.0.0.1
        scenarioWriteIPv4Address (0xc0a80148);  // 192.168.1.72
        scenarioWriteIPv4Address (0x55d63cb9);  // 85.214.60.185
        scenarioWriteIPv4Address (0x00000000);  // 0.0.0.0
    }

    void scenarioWriteQueryData (const QueryData &extension)
    {
        BinaryWriter    writer;
        writer.writeQueryData (extension);
        BinaryReader reader (writer.buffer());
        QueryData extension2 (reader.readQueryData());
        CPPUNIT_ASSERT (extension2.xmlList == extension.xmlList);
        CPPUNIT_ASSERT (extension2.urnList == extension.urnList);
        CPPUNIT_ASSERT (extension2.ggepBlock == extension.ggepBlock);
        CPPUNIT_ASSERT (extension2.unknownList == extension.unknownList);
        CPPUNIT_ASSERT (reader.hasReadAll() && !reader.hasReadPastEnd());
    }

    void testWriteQueryDataOneXml()
    {
        QueryData   extension;
        extension.xmlList += QByteArray ("{xmltest/}");
        scenarioWriteQueryData (extension);
    }

    void testWriteQueryDataOneHuge()
    {
        QueryData   extension;
        extension.urnList += QByteArray ("urn: fortest");
        scenarioWriteQueryData (extension);
    }

    void testWriteQueryDataOneUnknown()
    {
        QueryData   extension;
        extension.unknownList += QByteArray ("dunnotest");
        scenarioWriteQueryData (extension);
    }

    void testWriteQueryDataOneGgepBlock()
    {
        QueryData extension;
        extension.ggepBlock.addExtension (Ggeps::Unknown ("UNKN", "fortest"));
        scenarioWriteQueryData (extension);
    }

    void testWriteQueryDataMixed()
    {
        QueryData extension;
        extension.xmlList += QByteArray ("<xmltest/>");
        extension.xmlList += QByteArray ("{xmltest2/}");
        extension.urnList += QByteArray ("urn: hugetest");
        extension.unknownList += QByteArray ("dunnotest");
        extension.ggepBlock.addExtension (Ggeps::Unknown ("UNKN", "fortest"));
        scenarioWriteQueryData (extension);
    }

    void scenarioWriteMinSpeed(bool f1,bool f2,bool f3,bool f4,bool f5,bool f6,uchar byte)
    {
        MinSpeed speed(f1,f2,f3,f4,f5,f6,byte);
        BinaryWriter writer;
        writer.writeMinSpeed (speed);
        BinaryReader reader (writer.buffer());
        CPPUNIT_ASSERT (reader.readMinSpeed() == speed);
        CPPUNIT_ASSERT (reader.hasReadAll() && !reader.hasReadPastEnd());
    }

    void testWriteMinSpeed()
    {
        scenarioWriteMinSpeed (true, true, true, true, true, true, '\110');
        scenarioWriteMinSpeed (true, true, true, true, true, false, '\110');
        scenarioWriteMinSpeed (true, true, true, true, false, false, '\110');
        scenarioWriteMinSpeed (true, true, true, false, false, false, '\110');
        scenarioWriteMinSpeed (true, true, false, false, false, false, '\110');
        scenarioWriteMinSpeed (true, false, false, false, false, false, '\110');
    }

    void scenarioWriteResultSet(const ResultData &resultData, int number)
    {
        BinaryWriter writer;
        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);
        writer.writeQueryHitsResultSet (rs);
        BinaryReader reader (writer.buffer());
        CPPUNIT_ASSERT (reader.readQueryHitsResultSet (number) == rs);
        CPPUNIT_ASSERT (reader.hasReadAll() && !reader.hasReadPastEnd());
    }

    void testWriteResultSetOneResultOneUrn()
    {
        ResultData resultData;
        resultData.urnList.append ("urn:test");
        scenarioWriteResultSet (resultData, 1);
    }
    void testWriteResultSetOneResultOneGgepBlock()
    {
        ResultData resultData;
        resultData.ggepBlock = GgepBlock().addExtension (Ggeps::Unknown ("UNKN", "fortest"));
        scenarioWriteResultSet (resultData, 1);
    }

    void testWriteResultSetOneResultOnePlainData()
    {
        ResultData resultData;
        resultData.unknownList.append ("plain:test");
        scenarioWriteResultSet (resultData, 1);
    }

    void testWriteResultSetOneResultMixedData()
    {
        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>");
        scenarioWriteResultSet (resultData, 1);
    }

    void testWriteResultSetTwoResults()
    {
        scenarioWriteResultSet (ResultData(),  2);
    }

    void scenarioWriteQueryHitsDataCheckFlags (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.
        rawBytes += QByteArray (16, '\0'); // Null serventId.

        BinaryWriter writer;
        writer.writeQueryHitsData (hitsData);
        QByteArray writtenRawBytes = writer.buffer();

        CPPUNIT_ASSERT (writtenRawBytes.mid (5, 2) == QByteArray (flags));
    }

    void testWriteQueryHitsDataCheckFlagsAllSet()
    {
        scenarioWriteQueryHitsDataCheckFlags (true, true, true, true, true,
                                              "\x3d\x3d");
    }

    void testWriteQueryHitsDataCheckFlagsPushNotSet()
    {
        scenarioWriteQueryHitsDataCheckFlags (true, true, true, true, false,
                                              "\x3c\x3d");
    }

    void testWriteQueryHitsDataCheckFlagsBusyNotSet()
    {
        scenarioWriteQueryHitsDataCheckFlags (true, true, true, false, true,
                                              "\x3d\x39");
    }

    void testWriteQueryHitsDataCheckFlagsHaveUploadedNotSet()
    {
        scenarioWriteQueryHitsDataCheckFlags (true, true, false, true, true,
                                              "\x3d\x35");
    }

    void testWriteQueryHitsDataCheckFlagsUploadSpeedNotSet()
    {
        scenarioWriteQueryHitsDataCheckFlags (true, false, true, true, true,
                                              "\x3d\x2d");
    }

    void testWriteQueryHitsDataCheckFlagsGgepNotSet()
    {
        scenarioWriteQueryHitsDataCheckFlags (false, true, true, true, true,
                                              "\x3d\x1d");
    }

    void testWriteQueryHitsDataCheckFlagsNoneSet()
    {
        scenarioWriteQueryHitsDataCheckFlags (false, false, false, false, false,
                                              "\x3c\x01");
    }

    void scenarioWriteQueryHitsData(QueryHitsData &hitsData)
    {
        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);
        BinaryWriter writer;
        writer.writeQueryHitsData (hitsData);
        BinaryReader reader (writer.buffer());
        QueryHitsData readHitsData = reader.readQueryHitsData();
        CPPUNIT_ASSERT (hitsData == readHitsData);
        CPPUNIT_ASSERT (reader.hasReadAll() && !reader.hasReadPastEnd());
    }

    void testWriteQueryHitsDataNoGgepBlockNoXmlData()
    {
        QueryHitsData hitsData;
        scenarioWriteQueryHitsData (hitsData);
    }

    void testWriteQueryHitsDataXmlData()
    {
        QueryHitsData hitsData;
        hitsData.xmlData = QByteArray("<xmltest/>");
        scenarioWriteQueryHitsData (hitsData);
    }

    void testWriteQueryHitsDataGgepBlock()
    {
        QueryHitsData hitsData;
        hitsData.ggepBlock = GgepBlock().addExtension (Ggeps::Unknown ("UNKN", "fortest"));
        scenarioWriteQueryHitsData (hitsData);
    }

    void testWriteQueryHitsDataGgepBlockXmlData()
    {
        QueryHitsData hitsData;
        hitsData.xmlData = QByteArray("<xmltest/>");
        hitsData.ggepBlock = GgepBlock().addExtension (Ggeps::Unknown ("UNKN", "fortest"));
        scenarioWriteQueryHitsData (hitsData);
    }

    void testWriteQueryHitsDataGgepBlockXmlDataOther()
    {
        QueryHitsData hitsData;
        hitsData.privateVendor.append(QByteArray("vendor1"));
        hitsData.privateVendor.append(QByteArray("vendor2"));
        hitsData.xmlData = QByteArray("<xmltest/>");
        hitsData.ggepBlock = GgepBlock().addExtension (Ggeps::Unknown ("UNKN", "fortest"));
        scenarioWriteQueryHitsData (hitsData);
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION(BinaryWriterTest);

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

Copyright © 2006 Peter Dimov.
Powered by Doxygen.