BDecoderTest.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 "../BDecoder.h"
#include "../BDictionary.h"
#include "../BErrorItem.h"
#include "../BList.h"
#include "../BInt.h"
#include "../BString.h"
#include "cppunit/extensions/HelperMacros.h"
#include <sstream>
#include <limits>

namespace Protocols {
namespace BitTorrent {
namespace Bencoding {
namespace Testing {

class BDecoderTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE(BDecoderTest);
    CPPUNIT_TEST(testCtors);
    CPPUNIT_TEST(testReadTorrent);
    CPPUNIT_TEST(testMalFormedRead);
    CPPUNIT_TEST(testReadDictionary);
    CPPUNIT_TEST(testReadInvalidList);
    CPPUNIT_TEST(testReadValidQInt64);
    CPPUNIT_TEST(testReadOverflowingQInt64);
    CPPUNIT_TEST(testReadQInt64Max);
    CPPUNIT_TEST(testReadQInt64Min);
    CPPUNIT_TEST(testReadQuint64Max);
    CPPUNIT_TEST(testReadZero);
    CPPUNIT_TEST(testReadNegative);
    CPPUNIT_TEST(testReadValidListOneElement);
    CPPUNIT_TEST(testReadStringWithTooManyElements);
    CPPUNIT_TEST(testReadStringWithNoElement);
    CPPUNIT_TEST(testReadStringWithOneElement);
    CPPUNIT_TEST(testReadStringWithWrongCount);
    CPPUNIT_TEST(testReadDoubleAsInt);
    CPPUNIT_TEST_SUITE_END();

    auto_ptr <BItem> m_item;

private:
    QByteArray getBytes(const char *rawData) const
    {
        size_t len = strlen (rawData);
        return QByteArray::fromRawData (rawData, len);
    }

    template<class T>
    QByteArray stringifyNum(T num) const
    {
        std::stringstream ss;
        ss << "i"
           << num
           << "e";
        std::string s = ss.str();
        return QByteArray (s.c_str());
    }

    const BInt *getBInt(const BItem *item) const
    {
        const BInt *bInt = dynamic_cast <const BInt *> (item);
        return bInt;
    }

    const BInt *getBInt() const
    {
        return getBInt(m_item.get());
    }

    const BString *getBString(const BItem *item) const
    {
        const BString *str = dynamic_cast <const BString *> (item);
        return str;
    }

    const BList *getBList(const BItem *item) const
    {
        const BList *list = dynamic_cast <const BList *> (item);
        return list;
    }

    const BDictionary *getBDictionary(const BItem *item) const
    {
        const BDictionary *dict = dynamic_cast <const BDictionary *>(item);
        return dict;
    }

    QByteArray readTorrentFile (const char *fileName)
    {
        QFile torrentFile (fileName);
        torrentFile.open (QIODevice::ReadOnly);
        QByteArray buffer = torrentFile.readAll();
        return buffer;
    }

public:
    BDecoderTest();

    void testCtors()
    {
        QByteArray emptyBuffer;
        {
            BDecoder bDecoder (emptyBuffer);
            CPPUNIT_ASSERT (bDecoder.hasReadAll());
            CPPUNIT_ASSERT (!bDecoder.hasReadPassEnd());
        }
        QByteArray erronousBuffer (4, '\0');
        {
            BDecoder bDecoder (erronousBuffer);
            CPPUNIT_ASSERT (!bDecoder.hasReadAll());
            CPPUNIT_ASSERT (!bDecoder.hasReadPassEnd());
            m_item = bDecoder.readNext();
            CPPUNIT_ASSERT (typeid (*m_item) == typeid (BErrorItem));
        }
    }

    /* "d3:stri0e4:key2l7:calitkoi20ei-240eee" should indent as.. */
    /*               "d
                        3:str
                        i0e
                        4:key2
                        l
                            7:calitko
                            i20e
                            i-240e
                        e
                      e"        ;*/
    void testReadDictionary()
    {
        BDecoder bDecoder (getBytes("d3:stri0e4:key2l7:calitkoi20ei-240eee"));
        CPPUNIT_ASSERT (!bDecoder.hasReadAll());
        CPPUNIT_ASSERT (!bDecoder.hasReadPassEnd());

        m_item = bDecoder.readNext();
        CPPUNIT_ASSERT (bDecoder.hasReadAll());
        CPPUNIT_ASSERT (!bDecoder.hasReadPassEnd());
        CPPUNIT_ASSERT (typeid (*m_item) == typeid (BDictionary));

        const BDictionary *dict = getBDictionary(m_item.get());
        CPPUNIT_ASSERT (dict);

        const BInt *bint = getBInt(dict->item("str"));
        CPPUNIT_ASSERT (bint);
        CPPUNIT_ASSERT (bint->value() == 0);

        const BList *blist = getBList(dict->item ("key2"));
        CPPUNIT_ASSERT (blist);
        const BString *bstr = getBString(blist->item (0));
        CPPUNIT_ASSERT (bstr);
        CPPUNIT_ASSERT (bstr->value() == "calitko");

        bint = getBInt(blist->item (1));
        CPPUNIT_ASSERT (bint);
        CPPUNIT_ASSERT (bint->value() == 20);

        bint = getBInt(blist->item (2));
        CPPUNIT_ASSERT (bint);
        CPPUNIT_ASSERT (bint->value() == -240);
    }

    void testMalFormedRead()
    {
        BDecoder bDecoder (getBytes ("d3:sti0e4:key2l7:calitkoi20ei-240eee"));
        CPPUNIT_ASSERT (!bDecoder.hasReadAll());
        CPPUNIT_ASSERT (!bDecoder.hasReadPassEnd());
        m_item = bDecoder.readNext();
        CPPUNIT_ASSERT (typeid (*m_item) == typeid (BErrorItem));
    }

    void testReadStringWithTooManyElements()
    {
        BDecoder bDecoder (getBytes ("33333:sti0e4:key2l7:calitkoi20ei-240eee"));
        m_item = bDecoder.readNext();
        CPPUNIT_ASSERT (typeid (*m_item) == typeid (BErrorItem));
    }

    void testReadStringWithNoElement()
    {
        BDecoder bDecoder (getBytes ("0:0eee"));
        m_item = bDecoder.readNext();
        CPPUNIT_ASSERT (typeid (*m_item) == typeid (BErrorItem));
    }

    void testReadStringWithOneElement()
    {
        BDecoder bDecoder (getBytes ("1:1eee"));
        m_item = bDecoder.readNext();
        const BString* str = getBString(m_item.get());
        CPPUNIT_ASSERT (str);
        CPPUNIT_ASSERT (str->value() == "1");
    }

    void testReadStringWithWrongCount()
    {
        BDecoder bDecoder (getBytes("5:1eee"));
        m_item = bDecoder.readNext();
        CPPUNIT_ASSERT (typeid (*m_item) == typeid (BErrorItem));
    }

    void testReadValidQInt64()
    {
        BDecoder bDecoder (getBytes ("i33333e"));
        m_item = bDecoder.readNext();
        CPPUNIT_ASSERT (typeid (*m_item) == typeid (BInt));
    }

    void testReadOverflowingQInt64()
    {
        BDecoder bDecoder (getBytes ("i33333333333333333333333333333333333e"));
        m_item = bDecoder.readNext();
        CPPUNIT_ASSERT (typeid (*m_item) == typeid (BErrorItem));
    }

    void testReadQInt64Max()
    {
        BDecoder bDecoder (stringifyNum (std::numeric_limits<qint64>::max()));
        m_item = bDecoder.readNext();
        CPPUNIT_ASSERT (getBInt());
        CPPUNIT_ASSERT (getBInt()->value() == std::numeric_limits<qint64>::max());
    }

    void testReadQInt64Min()
    {
        BDecoder bDecoder (stringifyNum (std::numeric_limits<qint64>::min()));
        m_item = bDecoder.readNext();
        CPPUNIT_ASSERT (getBInt());
        CPPUNIT_ASSERT (getBInt()->value() == std::numeric_limits<qint64>::min());
    }

    void testReadQuint64Max()
    {
        BDecoder bDecoder (stringifyNum (std::numeric_limits<quint64>::max()));
        m_item = bDecoder.readNext();
        CPPUNIT_ASSERT (typeid (*m_item) == typeid (BErrorItem));
    }

    void testReadZero()
    {
        BDecoder bDecoder (stringifyNum (0));
        m_item = bDecoder.readNext();
        CPPUNIT_ASSERT (getBInt());
        CPPUNIT_ASSERT (getBInt()->value() == 0);
    }

    void testReadNegative()
    {
        BDecoder bDecoder (stringifyNum (-1));
        m_item = bDecoder.readNext();
        CPPUNIT_ASSERT (getBInt());
        CPPUNIT_ASSERT (getBInt()->value() == -1);
    }

    void testReadDoubleAsInt()
    {
        BDecoder bDecoder (stringifyNum (1.23));
        m_item = bDecoder.readNext();
        CPPUNIT_ASSERT (typeid (*m_item) == typeid (BErrorItem));
    }

    void testReadValidListOneElement()
    {
        BDecoder bDecoder (getBytes ("li123ee"));
        m_item = bDecoder.readNext();
        const BList *pList = getBList(m_item.get());
        CPPUNIT_ASSERT (pList);
        CPPUNIT_ASSERT (pList->size() == 1);
        const BInt *bInt = getBInt(pList->item(0));
        CPPUNIT_ASSERT (bInt);
        CPPUNIT_ASSERT (bInt->value() == 123);
    }

    void testReadInvalidList()
    {
        const char list[] = "li1ei1ei1ei1ei1ei1ei1ei1rei1ei1ei1e";
        BDecoder bDecoder (getBytes (list));
        m_item = bDecoder.readNext();
        CPPUNIT_ASSERT( typeid (*m_item) == typeid (BErrorItem));
    }

    void testReadTorrent()
    {
        QByteArray buffer = readTorrentFile ("Protocols/BitTorrent/Torrents/Testing/Samples/sample.torrent");
        BDecoder bDecoder (buffer);
        CPPUNIT_ASSERT (!bDecoder.hasReadAll());
        m_item = bDecoder.readNext();

        CPPUNIT_ASSERT (bDecoder.hasReadAllCorrectly());
        const BDictionary *dict = getBDictionary (m_item.get());
        CPPUNIT_ASSERT (dict);

        const BString *str = getBString (dict->item ("announce"));
        CPPUNIT_ASSERT (str);
        CPPUNIT_ASSERT (str->value() == "http://tracker.calitko.org/torrents.php?passkey=d7c034325e7274bb2s346c6fc5b71307");

        str = getBString (dict->item ("created by"));
        CPPUNIT_ASSERT (str);
        CPPUNIT_ASSERT (str->value() == "BitComet/0.54");

        const BInt *bint = getBInt (dict->item ("creation date"));
        CPPUNIT_ASSERT (bint);
        CPPUNIT_ASSERT (bint->value() == 1135459991);

        const BDictionary *info_dict = getBDictionary (dict->item ("info"));
        CPPUNIT_ASSERT (info_dict);

        const BList *list = getBList (info_dict->item ("files"));
        CPPUNIT_ASSERT (list);

        const BDictionary *dict1 = getBDictionary (list->item (1));
        CPPUNIT_ASSERT (dict1);

        list = getBList (dict1->item ("path.utf-8"));
        CPPUNIT_ASSERT (list);

        str = getBString (list->item (0));
        CPPUNIT_ASSERT (str->value() == "Calitko_doc.zip");

        str = getBString (info_dict->item ("pieces"));
        CPPUNIT_ASSERT (str);
        CPPUNIT_ASSERT (str->value().length() == 6540);
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION(BDecoderTest);

BDecoderTest::BDecoderTest()
    : m_item()
{
}

} // namespace Testing
} // namespace Bencoding
} // namespace BitTorrent
} // namespace Protocols

Copyright © 2006 Peter Dimov.
Powered by Doxygen.