GgepTest.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 "../Ggep.h"
#include "Utils/Encodings/Cobs.h"
#include "Utils/Encodings/Deflate.h"
#include "Imports.cpp"

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


class GgepTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE(GgepTest);
    CPPUNIT_TEST(testCtorEncodingFlagSet);
    CPPUNIT_TEST(testCtorCompressionFlagSet);
    CPPUNIT_TEST(testCtorReservedFlagSet);
    CPPUNIT_TEST(testCtorNoFlagSet);
    CPPUNIT_TEST(testCtorCompressionAndEncodingFlagsSet);
    CPPUNIT_TEST(testParseNoCompressionNoEncoding);
    CPPUNIT_TEST(testParseCompressionNoEncoding);
    CPPUNIT_TEST(testParseNoCompressionEncoding);
    CPPUNIT_TEST(testParseCompressionEncoding);
    CPPUNIT_TEST(testParseCompressionEncodingNullData);
    CPPUNIT_TEST(testRawDataCompressionNoEncoding);
    CPPUNIT_TEST(testRawDataNoCompressionNoEncoding);
    CPPUNIT_TEST(testRawDataCompressionEncoding);
    CPPUNIT_TEST(testRawDataNoCompressionNoEncoding);
    CPPUNIT_TEST(testRawDataCompressionEncodingNullData);
    CPPUNIT_TEST(testFromId);
    CPPUNIT_TEST(testOperatorEqualIdDifferent);
    CPPUNIT_TEST(testOperatorEqualDataDifferent);
    CPPUNIT_TEST(testOperatorEqualFlagDifferent);
    CPPUNIT_TEST(testOperatorEqualRealEqual);
    CPPUNIT_TEST_SUITE_END();

public:
    void scenarioCtor (int flags, bool encoding,
                       bool compression, bool reserved)
    {
        Ggeps::Unknown ggep ("unknown", "fortest", flags);
        CPPUNIT_ASSERT (ggep.isFlagSet (Ggep::Encoding) == encoding);
        CPPUNIT_ASSERT (ggep.isFlagSet (Ggep::Compression) == compression);
        CPPUNIT_ASSERT (ggep.isFlagSet (Ggep::Reserved) == reserved);
    }

    void testCtorEncodingFlagSet()
    {
        scenarioCtor (0x40, true, false, false);
    }

    void testCtorCompressionFlagSet()
    {
        scenarioCtor (0x20, false, true, false);
    }

    void testCtorReservedFlagSet()
    {
        scenarioCtor (0x10, false, false, true);
    }

    void testCtorNoFlagSet()
    {
        scenarioCtor (0x00, false, false, false);
    }

    void testCtorCompressionAndEncodingFlagsSet()
    {
        scenarioCtor (0x60, true, true, false);
    }


    void scenarioParse (const QByteArray &parsedData,
                        bool compress, bool encode)
    {
        QByteArray rawData = parsedData;
        int flags = 0;
        if (compress) {
            rawData = Utils::Encodings::Deflate::compress (rawData);
            flags |= Ggep::Compression;
        }
        if (encode) {
            rawData = Utils::Encodings::Cobs::encode (rawData);
            flags |= Ggep::Encoding;
        }
        Ggeps::Unknown ggep ("un", QByteArray(), flags);
        CPPUNIT_ASSERT (ggep.parse (rawData) == true);
        CPPUNIT_ASSERT (ggep.data() == parsedData);
    }

    void testParseNoCompressionNoEncoding()
    {
        scenarioParse ("fortest", false, false);
    }

    void testParseCompressionNoEncoding()
    {
        scenarioParse ("fortest", true, false);
    }

    void testParseNoCompressionEncoding()
    {
        scenarioParse ("fortest", false, true);
    }

    void testParseCompressionEncoding()
    {
        scenarioParse ("fortest", true, true);
    }

    void testParseCompressionEncodingNullData()
    {
        scenarioParse ("", true, true);
    }



    void scenarioRawData (const QByteArray& rawData,
                          bool compress, bool encode)
    {
        QByteArray encodeData = rawData;
        int flags = 0;
        if (compress) {
            encodeData = Utils::Encodings::Deflate::compress (encodeData);
            flags |= Ggep::Compression;
        }
        if (encode) {
            encodeData = Utils::Encodings::Cobs::encode (encodeData);
            flags |= Ggep::Encoding;
        }
        Ggeps::Unknown ggep ("un", rawData, flags);
        CPPUNIT_ASSERT (ggep.rawData() == encodeData);
    }

    void testRawDataCompressionNoEncoding()
    {
        scenarioRawData ("fortest", true, false);
    }

    void testRawDataNoCompressionNoEncoding()
    {
        scenarioRawData ("fortest", false, false);
    }

    void testRawDataCompressionEncoding()
    {
        scenarioRawData ("fortest", true, true);
    }

    void testRawDataNoCompressionEncoding()
    {
        scenarioRawData ("fortest", false, true);
    }

    void testRawDataCompressionEncodingNullData()
    {
        scenarioRawData ("", true, true);
    }

    void testFromId()
    {
        // the data test maybe placed in the rawData() test.
        // \todo for each Id test it.
        Ggep* ggep = Ggep::fromId("un", 0x00, "rawdata");
        CPPUNIT_ASSERT ( ggep->id() == "un" );
        delete ggep;
    }
    void scenarioOperatorEqual(const QByteArray &lid, const QByteArray &lrawData, \
        int lflags, const QByteArray &rid, const QByteArray &rrawData, int rflags)
    {
        Ggeps::Unknown lggep (lid, lrawData, lflags);
        Ggeps::Unknown rggep (rid, rrawData, rflags);
        bool result;
        result = lid == rid && lrawData == rrawData && lflags == rflags;
        CPPUNIT_ASSERT ( (lggep == rggep) == result );
    }
    void testOperatorEqualIdDifferent()
    {
        scenarioOperatorEqual ( "un",   "fortest",      0x80,\
                        "hehe",     "fortest",      0x80);
    }
    void testOperatorEqualDataDifferent()
    {
        scenarioOperatorEqual ( "un",   "fortest",      0x80,\
                        "un",   "fortest2",     0x80);
    }
    void testOperatorEqualFlagDifferent()
    {
        scenarioOperatorEqual ( "un",   "fortest",      0x80,\
                        "un",   "fortest",      0x40);
    }
    void testOperatorEqualRealEqual()
    {
        scenarioOperatorEqual ( "un",   "fortest",      0x80,\
                        "un",   "fortest",      0x80);
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION(GgepTest);

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

Copyright © 2006 Peter Dimov.
Powered by Doxygen.