PacketTest.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 "../Packet.h"
#include "../Bye.h"
#include "cppunit/extensions/HelperMacros.h"
#include <memory>

namespace Gnutella {
namespace Packets {
namespace Testing {

class ByeConcretePacket : public Bye
{
    public:
        typedef Packet::Data PacketData;

        ByeConcretePacket(  quint16 code,
                const QByteArray &message )
            : Bye( code, message )
            {
            }

        ByeConcretePacket( const QByteArray &rawHeader,
                           const QByteArray &rawPayload )
            : Bye( rawHeader, rawPayload )
        {
        }

        PacketData* getPacketData()
        {
            return this->Packet::d;
        }

        void setHeaderAndPayload( QByteArray& header,
                QByteArray& payload )
        {
            getPacketData()->rawHeader = header;
            getPacketData()->rawPayload = payload;
        }

        void invalidatePayload()
        {
            Packet::invalidatePayload();
        }
};

class TestPacket : public CppUnit::TestFixture
{
    REFERENCE_OBJECT (TestPacket)

    CPPUNIT_TEST_SUITE(TestPacket);
    CPPUNIT_TEST(testDescriptorCtor);
    CPPUNIT_TEST(testAssign);
    CPPUNIT_TEST(testInvalidateHeader);
    CPPUNIT_TEST(testReadHeader);
    CPPUNIT_TEST(testParse);
    CPPUNIT_TEST(testInvalidatePayload);
    CPPUNIT_TEST(testWriteHeader);
    CPPUNIT_TEST(testHeaderPayloadCtor);
    CPPUNIT_TEST(testRawPayload);
    CPPUNIT_TEST(testRawHeader);
    CPPUNIT_TEST(testFromRawData);
    CPPUNIT_TEST_SUITE_END();
    ByeConcretePacket* m_p;
    QByteArray      m_header;
    QByteArray      m_payload;
    QUuid           m_uid;
    enum { PAYLOADLEN = 34567, TTL = 144, HOPS = 49,
           MSGLEN = 44, MSGFILLCHAR = 'X' };

public:

    TestPacket() :
        m_p (0), m_header(), m_payload(),
        m_uid (0x67c8770b, 0x44f1, 0x410a, 0xab, 0x9a,
               0xf9, 0xb5, 0x44, 0x6f, 0x13, 0xee)
    {
    }

    void setUp()
    {
        createPacketStream( m_header, m_uid, ByeDescriptor, TTL, HOPS, PAYLOADLEN );
        m_payload.fill( ' ', PAYLOADLEN );
        QByteArray message( MSGLEN, MSGFILLCHAR );
        m_p = new ByeConcretePacket( 29, message );
    }

    void tearDown()
    {
        delete m_p;
    }

    void testDescriptorCtor()
    {
        ByeConcretePacket::PacketData* d = m_p->getPacketData();
        CPPUNIT_ASSERT( d->ref == 1 );
        CPPUNIT_ASSERT( d->descriptorId == m_p->descriptorId() );
        CPPUNIT_ASSERT( m_p->hops() == DefaultHops );
        CPPUNIT_ASSERT( m_p->ttl() == DefaultTtl );
        CPPUNIT_ASSERT( m_p->payloadDescriptor() == ByeDescriptor );
        CPPUNIT_ASSERT( d->payloadLength == 0 );
        CPPUNIT_ASSERT( d->rewriteHeader == true );
        CPPUNIT_ASSERT( d->rewritePayload == true );
        CPPUNIT_ASSERT( d->isValid );
        CPPUNIT_ASSERT( m_p->isValid() );
    }

    void testHeaderPayloadCtor()
    {
        const std::auto_ptr<ByeConcretePacket> p ( new ByeConcretePacket( m_header, m_payload ) );
        CPPUNIT_ASSERT( p->getPacketData()->ref == 1 );
        /* as the parse is done by now */
        CPPUNIT_ASSERT( p->isValid() == true );
        CPPUNIT_ASSERT( p->descriptorId() == m_uid );
        CPPUNIT_ASSERT( p->payloadDescriptor() == ByeDescriptor );
        CPPUNIT_ASSERT( p->ttl() == static_cast<uchar>(TTL) );
        CPPUNIT_ASSERT( p->hops() == static_cast<uchar>(HOPS) );
        CPPUNIT_ASSERT( p->getPacketData()->payloadLength ==
                static_cast<quint32>(PAYLOADLEN) );
    }

    void testAssign()
    {
        QByteArray message( MSGLEN, MSGFILLCHAR );
        std::auto_ptr<ByeConcretePacket> p( new ByeConcretePacket( 29,
                message ) );
        *p = *m_p;
        CPPUNIT_ASSERT( p->getPacketData() == m_p->getPacketData() );
        CPPUNIT_ASSERT( p->getPacketData()->ref == 2 );
        *m_p = *p;
        CPPUNIT_ASSERT( p->getPacketData() == m_p->getPacketData() );
        CPPUNIT_ASSERT( p->getPacketData()->ref == 2 );
        p->invalidateHeader();
        p.reset();
        CPPUNIT_ASSERT( m_p->getPacketData()->ref == 1 );
        ByeConcretePacket::PacketData* d = m_p->getPacketData();
        *m_p = *m_p;
        CPPUNIT_ASSERT( m_p->getPacketData() == d );
        CPPUNIT_ASSERT( m_p->getPacketData()->ref == 1 );
    }

    void testInvalidatePayload()
    {
        m_p->invalidatePayload();
        CPPUNIT_ASSERT( m_p->getPacketData()->rewritePayload == true );
        QByteArray message( MSGLEN, MSGFILLCHAR );
        std::auto_ptr<ByeConcretePacket> p( new ByeConcretePacket( 29, message ) );
        *p = *m_p;
        p->invalidatePayload();
        CPPUNIT_ASSERT( p->getPacketData() != m_p->getPacketData() );
        CPPUNIT_ASSERT( p->getPacketData()->ref == 1 );
        CPPUNIT_ASSERT( m_p->getPacketData()->ref == 1 );
        CPPUNIT_ASSERT( p->getPacketData()->rewritePayload == true );
        CPPUNIT_ASSERT( m_p->getPacketData()->rewritePayload == true );
    }

    void testInvalidateHeader()
    {
        ByeConcretePacket::PacketData* d = m_p->getPacketData();
        m_p->invalidateHeader();
        CPPUNIT_ASSERT( m_p->getPacketData() == d );
        CPPUNIT_ASSERT( m_p->getPacketData()->rewriteHeader == true );
        CPPUNIT_ASSERT( m_p->getPacketData()->ref == 1 );
        QByteArray message( MSGLEN, MSGFILLCHAR );
        std::auto_ptr<ByeConcretePacket> p( new ByeConcretePacket( 29, message ) );
        std::auto_ptr<ByeConcretePacket> q( new ByeConcretePacket( 29, message ) );
        *p = *m_p;
        *q = *m_p;
        d = m_p->getPacketData();
        p->invalidateHeader();
        CPPUNIT_ASSERT( q->getPacketData() == d );
        CPPUNIT_ASSERT( q->getPacketData()->ref == 2 );
        CPPUNIT_ASSERT( q->getPacketData() != p->getPacketData() );
        CPPUNIT_ASSERT( q->getPacketData()->rewriteHeader == true );
        CPPUNIT_ASSERT( p->getPacketData()->rewriteHeader == true );
    }

    void createPacketStream(QByteArray& arr,
                            QUuid& uid,
                            PayloadDescriptor desc,
                            uchar ttl,
                            uchar hops,
                            quint32 payloadLength)
    {
        QDataStream stream(&arr, QIODevice::WriteOnly);
        stream.setByteOrder (QDataStream::LittleEndian);
        stream << uid
            << desc
            << ttl
            << hops
            << payloadLength;
    }

    void testReadHeader()
    {
        QByteArray arr;
        createPacketStream( arr, m_uid, ByeDescriptor, TTL, HOPS, PAYLOADLEN );
        QDataStream stream( &arr, QIODevice::ReadOnly );
        stream.setByteOrder (QDataStream::LittleEndian);
        m_p->readHeader( stream );
        CPPUNIT_ASSERT( m_p->descriptorId() == m_uid );
        CPPUNIT_ASSERT( m_p->payloadDescriptor() == ByeDescriptor );
        CPPUNIT_ASSERT( m_p->ttl() == static_cast<uchar>(TTL) );
        CPPUNIT_ASSERT( m_p->hops() == static_cast<uchar>(HOPS) );
        CPPUNIT_ASSERT( m_p->getPacketData()->payloadLength ==
                static_cast<quint32>(PAYLOADLEN) );
    }

    void testParse()
    {
        m_p->setHeaderAndPayload( m_header, m_payload );
        m_p->parse();
        CPPUNIT_ASSERT( m_p->descriptorId() == m_uid );
        CPPUNIT_ASSERT( m_p->isValid() == true );
    }

    void testWriteHeader()
    {
        m_p->setHeaderAndPayload( m_header, m_payload );
        m_p->parse();
        QByteArray arr;
        QBuffer buffer(&arr);
        buffer.open(QIODevice::ReadWrite);
        QDataStream stream( &buffer );
        m_p->writeHeader(stream);
        buffer.seek(0);
        QUuid uid;
        PayloadDescriptor desc;
        uchar ttl;
        uchar hops;
        quint32 payloadLength;
        stream >> uid >> desc >> ttl >> hops >> payloadLength;
        CPPUNIT_ASSERT( uid == m_uid );
        CPPUNIT_ASSERT( desc == ByeDescriptor );
        CPPUNIT_ASSERT( ttl == m_p->ttl() );
        CPPUNIT_ASSERT( hops == m_p->hops() );
        CPPUNIT_ASSERT( payloadLength == PAYLOADLEN );
    }

    void testRawPayload()
    {
        const std::auto_ptr<ByeConcretePacket> p ( new ByeConcretePacket( m_header, m_payload ) );
        QByteArray empty;
        p->setIsValid(false);
        CPPUNIT_ASSERT( p->rawPayload() == empty );
        p->setIsValid(true);
        QByteArray payload = p->rawPayload();
        CPPUNIT_ASSERT( payload != empty );
        CPPUNIT_ASSERT( static_cast <uint> (payload.length()) ==
                        p->getPacketData()->payloadLength );
        CPPUNIT_ASSERT( p->getPacketData()->rewritePayload == false );
    }

    void testRawHeader()
    {
        const std::auto_ptr<ByeConcretePacket> p ( new ByeConcretePacket( m_header, m_payload ) );
        QByteArray empty;
        p->setIsValid(false);
        CPPUNIT_ASSERT( p->rawHeader() == empty );
        p->setIsValid(true);
        QByteArray rawHeader = p->rawHeader();
        CPPUNIT_ASSERT( rawHeader != empty );
        CPPUNIT_ASSERT( rawHeader.length() ==
                p->getPacketData()->rawHeader.length() );
        CPPUNIT_ASSERT( p->getPacketData()->rewriteHeader == false );
    }

    void testFromRawData()
    {
        auto_ptr <Packet> p (Packet::fromRawData(m_header, m_payload));
//      CPPUNIT_ASSERT( p->payloadDescriptor() == ByeDescriptor );
    }
};
CPPUNIT_TEST_SUITE_REGISTRATION(TestPacket);

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

Copyright © 2006 Peter Dimov.
Powered by Doxygen.