// TranslatorTestAddOn.cpp

#include <stdio.h>
#include <string.h>
#include <Translator.h>
#include <OS.h>
#include "TranslatorTestAddOn.h"

// ##### Include headers for your tests here #####
#include "bmptranslator/BMPTranslatorTest.h"
#include "pngtranslator/PNGTranslatorTest.h"
#include "stxttranslator/STXTTranslatorTest.h"
#include "tgatranslator/TGATranslatorTest.h"
#include "tifftranslator/TIFFTranslatorTest.h"

BTestSuite *
getTestSuite()
{
        BTestSuite *suite = new BTestSuite("Translators");

        // ##### Add test suites here #####
        suite->addTest("BMPTranslator", BMPTranslatorTest::Suite());
        suite->addTest("PNGTranslator", PNGTranslatorTest::Suite());
        suite->addTest("STXTTranslator", STXTTranslatorTest::Suite());
        suite->addTest("TGATranslator", TGATranslatorTest::Suite());
        suite->addTest("TIFFTranslator", TIFFTranslatorTest::Suite());

        return suite;
}

// helper function used by multiple tests to
// determine if the given streams are exactly
// the same
bool
CompareStreams(BPositionIO &a, BPositionIO &b)
{
        off_t alen = 0, blen = 0;
        const uint32 kbuflen = 2048;
        uint8 abuf[kbuflen], bbuf[kbuflen];

        a.Seek(0, SEEK_END);
        alen = a.Position();
        b.Seek(0, SEEK_END);
        blen = b.Position();
        if (alen != blen)
                return false;

        if (a.Seek(0, SEEK_SET) != 0)
                return false;
        if (b.Seek(0, SEEK_SET) != 0)
                return false;

        ssize_t read = 0;
        while (alen > 0) {
                read = a.Read(abuf, kbuflen);
                if (read < 0)
                        return false;
                if (b.Read(bbuf, read) != read)
                        return false;

                if (memcmp(abuf, bbuf, read) != 0)
                        return false;

                alen -= read;
        }

        return true;
}

// Check each member of translator_info to see that it matches
// what is expected
void
CheckTranslatorInfo(translator_info *pti, uint32 type, uint32 group,
        float quality, float capability, const char *name, const char *mime)
{
        CPPUNIT_ASSERT(pti->type == type);
        CPPUNIT_ASSERT(pti->translator != 0);
        CPPUNIT_ASSERT(pti->group == group);
        CPPUNIT_ASSERT(pti->quality > quality - 0.01f &&
                pti->quality < quality + 0.01f);
        CPPUNIT_ASSERT(pti->capability > capability - 0.01f &&
                pti->capability < capability + 0.01f);
        CPPUNIT_ASSERT(strcmp(pti->name, name) == 0);
        CPPUNIT_ASSERT(strcmp(pti->MIME, mime) == 0);
}

// Returns true if the translation_formats are
// identical (or nearly identical).  Returns false if
// they are different
bool
CompareTranslationFormat(const translation_format *pleft,
        const translation_format *pright)
{
        CPPUNIT_ASSERT(pleft->MIME);
        CPPUNIT_ASSERT(pright->MIME);
        CPPUNIT_ASSERT(pleft->name);
        CPPUNIT_ASSERT(pright->name);

        if (pleft->group != pright->group)
                return false;
        if (pleft->type != pright->type)
                return false;
        if (pleft->quality < pright->quality - 0.01f ||
                pleft->quality > pright->quality + 0.01f)
                return false;
        if (pleft->capability < pright->capability - 0.01f ||
                pleft->capability > pright->capability + 0.01f)
                return false;
        if (strcmp(pleft->MIME, pright->MIME) != 0)
                return false;
        if (strcmp(pleft->name, pright->name) != 0)
                return false;

        return true;
}

// Apply a number of tests to a BTranslator * to a TGATranslator object
void
TestBTranslator(BTestCase *ptest, BTranslator *ptran,
        const translation_format *pExpectedIns, uint32 nExpectedIns,
        const translation_format *pExpectedOuts, uint32 nExpectedOuts,
        int32 expectedVer)
{
        const uint32 knmatches = 50;
        uint8 matches[knmatches];
        CPPUNIT_ASSERT(nExpectedIns <= knmatches && nExpectedOuts <= knmatches);

        // The translator should only have one reference
        ptest->NextSubTest();
        CPPUNIT_ASSERT(ptran->ReferenceCount() == 1);

        // Make sure Acquire returns a BTranslator even though its
        // already been Acquired once
        ptest->NextSubTest();
        CPPUNIT_ASSERT(ptran->Acquire() == ptran);

        // Acquired twice, refcount should be 2
        ptest->NextSubTest();
        CPPUNIT_ASSERT(ptran->ReferenceCount() == 2);

        // Release should return ptran because it is still acquired
        ptest->NextSubTest();
        CPPUNIT_ASSERT(ptran->Release() == ptran);

        ptest->NextSubTest();
        CPPUNIT_ASSERT(ptran->ReferenceCount() == 1);

        ptest->NextSubTest();
        CPPUNIT_ASSERT(ptran->Acquire() == ptran);

        ptest->NextSubTest();
        CPPUNIT_ASSERT(ptran->ReferenceCount() == 2);

        ptest->NextSubTest();
        CPPUNIT_ASSERT(ptran->Release() == ptran);

        ptest->NextSubTest();
        CPPUNIT_ASSERT(ptran->ReferenceCount() == 1);

        // A name would be nice
        ptest->NextSubTest();
        const char *tranname = ptran->TranslatorName();
        CPPUNIT_ASSERT(tranname);
        printf(" {%s} ", tranname);

        // More info would be nice
        ptest->NextSubTest();
        const char *traninfo = ptran->TranslatorInfo();
        CPPUNIT_ASSERT(traninfo);
        printf(" {%s} ", traninfo);

        // What version are you?
        // (when ver == 100, that means that version is 1.00)
        ptest->NextSubTest();
        int32 ver = ptran->TranslatorVersion();
        CPPUNIT_ASSERT(ver == expectedVer);
        printf(" {0x%.8lx} ", ver);

        // Input formats?
        ptest->NextSubTest();
        {
                printf("input:");

                int32 incount = 0;
                const translation_format *pins = ptran->InputFormats(&incount);
                CPPUNIT_ASSERT((unsigned)incount == nExpectedIns);
                CPPUNIT_ASSERT(pins);

                memset(matches, 0, sizeof(uint8) * nExpectedIns);
                for (int32 i = 0; i < incount; i++) {
                        bool bmatch = false;
                        for (uint32 k = 0; bmatch == false && k < nExpectedIns; k++) {
                                bmatch = CompareTranslationFormat(pins + i, pExpectedIns + k);
                                if (bmatch)
                                        matches[k] = 1;
                        }

                        CPPUNIT_ASSERT(bmatch);
                }

                // make sure that each expected input format was matched
                for (uint32 i = 0; i < nExpectedIns; i++)
                        CPPUNIT_ASSERT(matches[i]);
        }

        // Output formats?
        ptest->NextSubTest();
        {
                printf("output:");

                int32 outcount = 0;
                const translation_format *pouts = ptran->OutputFormats(&outcount);
                CPPUNIT_ASSERT((unsigned)outcount == nExpectedOuts);
                CPPUNIT_ASSERT(pouts);

                memset(matches, 0, sizeof(uint8) * nExpectedOuts);
                for (int32 i = 0; i < outcount; i++) {
                        bool bmatch = false;
                        for (uint32 k = 0; bmatch == false && k < nExpectedOuts; k++) {
                                bmatch = CompareTranslationFormat(pouts + i, pExpectedOuts + k);
                                if (bmatch)
                                        matches[k] = 1;
                        }

                        CPPUNIT_ASSERT(bmatch);
                }

                // make sure that each expected input format was matched
                for (uint32 i = 0; i < nExpectedOuts; i++)
                        CPPUNIT_ASSERT(matches[i]);
        }

        // Release should return NULL because Release has been called
        // as many times as it has been acquired
        ptest->NextSubTest();
        CPPUNIT_ASSERT(ptran->Release() == NULL);
        ptran = NULL;
}

void
TranslatorLoadAddOnTest(const char *path, BTestCase *ptest,
        const translation_format *pExpectedIns, uint32 nExpectedIns,
        const translation_format *pExpectedOuts, uint32 nExpectedOuts,
        int32 expectedVer)
{
        // Make sure the add_on loads
        ptest->NextSubTest();
        image_id image = load_add_on(path);
        CPPUNIT_ASSERT(image >= 0);

        // Load in function to make the object
        ptest->NextSubTest();
        BTranslator *(*pMakeNthTranslator)(int32 n,image_id you,uint32 flags,...);
        status_t err = get_image_symbol(image, "make_nth_translator",
                B_SYMBOL_TYPE_TEXT, (void **)&pMakeNthTranslator);
        CPPUNIT_ASSERT(!err);

        // Make sure the function returns a pointer to a BTranslator
        ptest->NextSubTest();
        BTranslator *ptran = pMakeNthTranslator(0, image, 0);
        CPPUNIT_ASSERT(ptran);

        // Make sure the function only returns one BTranslator
        ptest->NextSubTest();
        CPPUNIT_ASSERT(!pMakeNthTranslator(1, image, 0));
        CPPUNIT_ASSERT(!pMakeNthTranslator(2, image, 0));
        CPPUNIT_ASSERT(!pMakeNthTranslator(3, image, 0));
        CPPUNIT_ASSERT(!pMakeNthTranslator(16, image, 0));
        CPPUNIT_ASSERT(!pMakeNthTranslator(1023, image, 0));

        // Run a number of tests on the BTranslator object
        TestBTranslator(ptest, ptran, pExpectedIns, nExpectedIns,
                pExpectedOuts, nExpectedOuts, expectedVer);
                // NOTE: this function Release()s ptran
        ptran = NULL;

        // Unload Add-on
        ptest->NextSubTest();
        CPPUNIT_ASSERT(unload_add_on(image) == B_OK);
}