PacketBaseTest.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 "PacketStub.h"
#include "Imports.cpp"

namespace Protocols {
namespace Generics {
namespace Testing {


class PacketTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (PacketTest);
    CPPUNIT_TEST (testReadPacket);
    CPPUNIT_TEST (testWritePacket);
    CPPUNIT_TEST (testReferenceCountIncreaseCopyPacket);
    CPPUNIT_TEST (testReferenceCountIncreaseAssignPacket);
    CPPUNIT_TEST (testReferenceCountDecreaseAssignPacket);
    CPPUNIT_TEST (testReferenceCountDecreaseDestroyPacket);
    CPPUNIT_TEST (testReferenceCountDecreaseModifyPacketCopyPrivateData);
    CPPUNIT_TEST (testCtorNoRawDataCached);
    CPPUNIT_TEST (testParseRawDataCached);
    CPPUNIT_TEST (testInvalidateHeader);
    CPPUNIT_TEST (testInvalidatePayload);
    CPPUNIT_TEST (testRawHeaderUsingCachedHeader);
    CPPUNIT_TEST (testRawHeaderRebuildingAndCachingHeader);
    CPPUNIT_TEST (testRawPayloadUsingCachedPayload);
    CPPUNIT_TEST (testRawPayloadRebuildingAndCachingPayload);
    CPPUNIT_TEST (testRebuildPacketNotModifyingReferenceCount);
    CPPUNIT_TEST_SUITE_END();

public:
    void testReadPacket()
    {
        PacketStub packet;
        CPPUNIT_ASSERT (packet.parse ("myHeader", "myPayload"));
        CPPUNIT_ASSERT ("myHeader" == packet.header());
        CPPUNIT_ASSERT ("myPayload" == packet.payload());

        /* That's how I wish I were able to write the WHITEBOX version of it:
        packet->parse (rawHeader, rawPayload, rawTrailer)
            .willReturn (true);
        packet->rawHeader()
            .willNotCall (packet->writeHeader())
            .willReturn (rawHeader);
        packet->rawPayload()
            .willNotCall (packet->writePayload())
            .willReturn (rawPayload);
        */
    }

    void testWritePacket()
    {
        PacketStub packet ("rawHeader", "rawPayload");
        CPPUNIT_ASSERT ("rawHeader" == packet.rawHeader());
        CPPUNIT_ASSERT ("rawPayload" == packet.rawPayload());
    }

    void testReferenceCountIncreaseCopyPacket()
    {
        PacketStub packet1;
        CPPUNIT_ASSERT (packet1.d_ptr.constData()->ref == 1);
        PacketStub packet2 (packet1);
        CPPUNIT_ASSERT (packet1.d_ptr.constData()->ref == 2);
        // Make sure the private data is indeed the same:
        CPPUNIT_ASSERT (packet1.d_ptr.constData() == packet2.d_ptr.constData());
    }

    void testReferenceCountIncreaseAssignPacket()
    {
        PacketStub packet1;
        CPPUNIT_ASSERT (packet1.d_ptr.constData()->ref == 1);
        PacketStub packet2;
        CPPUNIT_ASSERT (packet2.d_ptr.constData()->ref == 1);
        // Do the assignment:
        packet2 = packet1;
        CPPUNIT_ASSERT (packet1.d_ptr.constData()->ref == 2);
        // Make sure the private data is indeed the same:
        CPPUNIT_ASSERT (packet1.d_ptr.constData() == packet2.d_ptr.constData());
    }

    void testReferenceCountDecreaseAssignPacket()
    {
        PacketStub packet1, packet2, packet3;
        CPPUNIT_ASSERT (packet1.d_ptr.constData()->ref == 1);
        CPPUNIT_ASSERT (packet2.d_ptr.constData()->ref == 1);
        CPPUNIT_ASSERT (packet3.d_ptr.constData()->ref == 1);
        packet3 = packet1;
        CPPUNIT_ASSERT (packet1.d_ptr.constData()->ref == 2);
        CPPUNIT_ASSERT (packet2.d_ptr.constData()->ref == 1);
        CPPUNIT_ASSERT (packet3.d_ptr.constData()->ref == 2);
        packet3 = packet2;
        CPPUNIT_ASSERT (packet1.d_ptr.constData()->ref == 1);
        CPPUNIT_ASSERT (packet2.d_ptr.constData()->ref == 2);
        CPPUNIT_ASSERT (packet3.d_ptr.constData()->ref == 2);
        packet3 = PacketStub();
        CPPUNIT_ASSERT (packet1.d_ptr.constData()->ref == 1);
        CPPUNIT_ASSERT (packet2.d_ptr.constData()->ref == 1);
        CPPUNIT_ASSERT (packet3.d_ptr.constData()->ref == 1);
    }

    void testReferenceCountDecreaseDestroyPacket()
    {
        PacketStub packet1;
        {
            PacketStub packet2 (packet1);
            CPPUNIT_ASSERT (packet1.d_ptr.constData()->ref == 2);
        }
        CPPUNIT_ASSERT (packet1.d_ptr.constData()->ref == 1);
    }

    void testReferenceCountDecreaseModifyPacketCopyPrivateData()
    {
        PacketStub packet1;
        PacketStub packet2 (packet1);
        CPPUNIT_ASSERT (packet1.d_ptr.constData()->ref == 2);
        CPPUNIT_ASSERT (packet1.d_ptr.constData() == packet2.d_ptr.constData());
        packet2.invalidateHeader(); // is called by setter for header fields
        CPPUNIT_ASSERT (packet1.d_ptr.constData()->ref == 1);
        CPPUNIT_ASSERT (packet1.d_ptr.constData() != packet2.d_ptr.constData());
    }

    void testCtorNoRawDataCached()
    {
        PacketStub packet;
        CPPUNIT_ASSERT (true == packet.PacketBase::d_func()->rewriteHeader);
        CPPUNIT_ASSERT (true == packet.PacketBase::d_func()->rewritePayload);
    }


    void testParseRawDataCached()
    {
        PacketStub packet;
        CPPUNIT_ASSERT (packet.parse ("myHeader", "myPayload"));
        // Check rewrite* flags:
        CPPUNIT_ASSERT (false == packet.PacketBase::d_func()->rewriteHeader);
        CPPUNIT_ASSERT (false == packet.PacketBase::d_func()->rewritePayload);
        // Check the cached bytes are correct:
        CPPUNIT_ASSERT ("myHeader" == packet.rawHeader());
        CPPUNIT_ASSERT ("myPayload" == packet.rawPayload());
    }

    void testInvalidateHeader()
    {
        PacketStub packet;
        packet.PacketBase::d_func()->rewriteHeader = false;
        packet.invalidateHeader();
        CPPUNIT_ASSERT (true == packet.PacketBase::d_func()->rewriteHeader);
    }

    void testInvalidatePayload()
    {
        PacketStub packet;
        packet.PacketBase::d_func()->rewritePayload = false;
        packet.invalidatePayload();
        CPPUNIT_ASSERT (true == packet.PacketBase::d_func()->rewritePayload);
    }

    void testRawHeaderUsingCachedHeader()
    {
        PacketStub packet ("rawHeader");
        CPPUNIT_ASSERT (packet.rawHeader() == "rawHeader");
        // Set internal state to have cached "blah" for header raw bytes:
        packet.PacketBase::d_func()->rewriteHeader = false;
        packet.PacketBase::d_func()->rawHeader = "blah";
        // Verify that the new cached bytes are returned:
        CPPUNIT_ASSERT (packet.rawHeader() == "blah");
    }

    void testRawHeaderRebuildingAndCachingHeader()
    {
        PacketStub packet ("rawHeader");
        CPPUNIT_ASSERT (packet.PacketBase::d_func()->rewriteHeader == true);
        CPPUNIT_ASSERT (packet.PacketBase::d_func()->rawHeader == QByteArray());
        CPPUNIT_ASSERT (packet.rawHeader() == "rawHeader");
        CPPUNIT_ASSERT (packet.PacketBase::d_func()->rewriteHeader == false);
        CPPUNIT_ASSERT (packet.PacketBase::d_func()->rawHeader == "rawHeader");
    }

    void testRawPayloadUsingCachedPayload()
    {
        PacketStub packet ("", "rawPayload");
        CPPUNIT_ASSERT (packet.rawPayload() == "rawPayload");
        // Set internal state to have cached "blah" for payload raw bytes:
        packet.PacketBase::d_func()->rewritePayload = false;
        packet.PacketBase::d_func()->rawPayload = "blah";
        // Verify that the new cached bytes are returned:
        CPPUNIT_ASSERT (packet.rawPayload() == "blah");
    }

    void testRawPayloadRebuildingAndCachingPayload()
    {
        PacketStub packet ("", "rawPayload");
        CPPUNIT_ASSERT (packet.PacketBase::d_func()->rewritePayload == true);
        CPPUNIT_ASSERT (packet.PacketBase::d_func()->rawPayload == QByteArray());
        CPPUNIT_ASSERT (packet.rawPayload() == "rawPayload");
        CPPUNIT_ASSERT (packet.PacketBase::d_func()->rewritePayload == false);
        CPPUNIT_ASSERT (packet.PacketBase::d_func()->rawPayload == "rawPayload");
    }

    void testRebuildPacketNotModifyingReferenceCount()
    {
        // Construct a packet that does not cache raw bytes:
        PacketStub packet1 ("rawHeader", "rawPayload");
        CPPUNIT_ASSERT (packet1.PacketBase::d_func()->rewriteHeader == true);
        CPPUNIT_ASSERT (packet1.PacketBase::d_func()->rewritePayload == true);
        // Copy the packet and verify that both share the same private data:
        PacketStub packet2 (packet1);
        CPPUNIT_ASSERT (packet1.d_ptr.constData() == packet2.d_ptr.constData());
        // Force packet1 to be rebuilt and verify private data is still shared:
        // Header first:
        CPPUNIT_ASSERT (packet1.rawHeader() == "rawHeader");
        CPPUNIT_ASSERT (packet1.d_ptr.constData() == packet2.d_ptr.constData());
        CPPUNIT_ASSERT (packet2.rawHeader() == "rawHeader");
        // Payload next:
        CPPUNIT_ASSERT (packet1.rawPayload() == "rawPayload");
        CPPUNIT_ASSERT (packet1.d_ptr.constData() == packet2.d_ptr.constData());
        CPPUNIT_ASSERT (packet2.rawPayload() == "rawPayload");
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION(PacketTest);

} // namespace Testing
} // namespace Generics
} // namespace Protocols

Copyright © 2006 Peter Dimov.
Powered by Doxygen.