//------------------------------------------------------------------------------
//      SendMessageTester.cpp
//
//------------------------------------------------------------------------------

// Standard Includes -----------------------------------------------------------
#include <stdio.h>

// System Includes -------------------------------------------------------------
#include <Message.h>
#include <OS.h>
#include <Handler.h>
#include <Looper.h>
#include <Messenger.h>

// Project Includes ------------------------------------------------------------
#include <TestUtils.h>
#include <ThreadedTestCaller.h>
#include <cppunit/TestSuite.h>

// Local Includes --------------------------------------------------------------
#include "Helpers.h"
#include "SendMessageTester.h"
#include "SMInvoker.h"
#include "SMLooper.h"
#include "SMReplyTarget.h"
#include "SMTarget.h"

// Local Defines ---------------------------------------------------------------

// Globals ---------------------------------------------------------------------

// target flavors
enum target_kind {
        TARGET_UNINITIALIZED,
        TARGET_LOCAL_PREFERRED,
        TARGET_LOCAL_SPECIFIC,
        TARGET_REMOTE_PREFERRED,
        TARGET_REMOTE_SPECIFIC,
};

// tester class
class SMTester {
public:
        SMTester(target_kind targetKind)
                : fTargetKind(targetKind)
        {
        }

        ~SMTester()
        {
        }

        void Run(SMInvoker &invoker, bigtime_t targetUnblock,
                         bigtime_t targetReply, status_t result, bool deliverySuccess,
                         bool replySuccess, bigtime_t duration)
        {
//printf("SMTester::Run(%lld, %lld, %lx, %d, %d, %lld)\n", targetUnblock,
//targetReply, result, deliverySuccess, replySuccess, duration);
                enum { JITTER = 10000 };
                enum { SETUP_LATENCY = 100000 };
                enum { DELIVERY_LATENCY = 10000 };
                enum { TARGET_HEAD_START = 1000 };
                if (targetUnblock == 0)
                        targetUnblock = -TARGET_HEAD_START;
                // create the target
                SMTarget *target = NULL;
                switch (fTargetKind) {
                        case TARGET_UNINITIALIZED:
                                target = new SMTarget;
                                break;
                        case TARGET_LOCAL_PREFERRED:
                                target = new LocalSMTarget(true);
                                break;
                        case TARGET_LOCAL_SPECIFIC:
                                target = new LocalSMTarget(false);
                                break;
                        case TARGET_REMOTE_PREFERRED:
                                target = new RemoteSMTarget(true);
                                break;
                        case TARGET_REMOTE_SPECIFIC:
                                target = new RemoteSMTarget(false);
                                break;
                }
                AutoDeleter<SMTarget> deleter(target);
                // create the reply target
                SMReplyTarget replyTarget;
                // init the target and send the message
                BHandler *replyHandler = replyTarget.Handler();
                BMessenger replyMessenger = replyTarget.Messenger();
                bigtime_t startTime = system_time() + SETUP_LATENCY;
                target->Init(startTime + targetUnblock, targetReply);
                BMessenger targetMessenger = target->Messenger();
                snooze_until(startTime, B_SYSTEM_TIMEBASE);
                status_t actualResult = invoker.Invoke(targetMessenger, replyHandler,
                                                                                           replyMessenger);
                bigtime_t actualDuration = system_time() - startTime;
//printf("duration: %lld vs %lld\n", actualDuration, duration);
                // We need to wait for the reply, if reply mode is asynchronous.
                snooze_until(startTime + targetUnblock + targetReply
                                         + 2 * DELIVERY_LATENCY, B_SYSTEM_TIMEBASE);
                bool actualReplySuccess = invoker.ReplySuccess();
                if (!invoker.DirectReply())
                        actualReplySuccess = replyTarget.ReplySuccess();
                // check the results
if (actualResult != result)
printf("result: %lx vs %lx\n", actualResult, result);
                CHK(actualResult == result);
                CHK(target->DeliverySuccess() == deliverySuccess);
                CHK(actualReplySuccess == replySuccess);
                CHK(actualDuration > duration - JITTER
                        && actualDuration < duration + JITTER);
        }

private:
        target_kind     fTargetKind;
};


//------------------------------------------------------------------------------

// constructor
SendMessageTester::SendMessageTester()
        : BThreadedTestCase(),
          fHandler(NULL),
          fLooper(NULL)
{
}

// constructor
SendMessageTester::SendMessageTester(std::string name)
        : BThreadedTestCase(name),
          fHandler(NULL),
          fLooper(NULL)
{
}

// destructor
SendMessageTester::~SendMessageTester()
{
        if (fLooper) {
                fLooper->Lock();
                if (fHandler) {
                        fLooper->RemoveHandler(fHandler);
                        delete fHandler;
                }
                fLooper->Quit();
        }
}

// TestUninitialized
void
SendMessageTester::TestUninitialized()
{
        SMTester tester(TARGET_UNINITIALIZED);
        // status_t SendMessage(uint32 command, BHandler *replyTo) const
        NextSubTest();
        {
                SMInvoker1 invoker1(false);
                SMInvoker1 invoker2(true);
                tester.Run(invoker1, 0, 0, B_BAD_PORT_ID, false, false, 0);
                tester.Run(invoker2, 0, 0, B_BAD_PORT_ID, false, false, 0);
        }
        // status_t SendMessage(BMessage *message, BHandler *replyTo,
        //                                              bigtime_t timeout) const
        NextSubTest();
        {
                SMInvoker2 invoker1(true, false, B_INFINITE_TIMEOUT);
                SMInvoker2 invoker2(true, true, B_INFINITE_TIMEOUT);
                tester.Run(invoker1, 0, 0, B_BAD_PORT_ID, false, false, 0);
                tester.Run(invoker2, 0, 0, B_BAD_PORT_ID, false, false, 0);
        }
        // status_t SendMessage(BMessage *message, BMessenger replyTo,
        //                                              bigtime_t timeout) const
        NextSubTest();
        {
                SMInvoker3 invoker1(true, false, B_INFINITE_TIMEOUT);
                SMInvoker3 invoker2(true, true, B_INFINITE_TIMEOUT);
                tester.Run(invoker1, 0, 0, B_BAD_PORT_ID, false, false, 0);
                tester.Run(invoker2, 0, 0, B_BAD_PORT_ID, false, false, 0);
        }
        // status_t SendMessage(uint32 command, BMessage *reply) const
        NextSubTest();
        {
                SMInvoker4 invoker1(false);
                SMInvoker4 invoker2(true);
// We check the parameters first.
#ifdef TEST_OBOS
                tester.Run(invoker1, 0, 0, B_BAD_VALUE, false, false, 0);
#else
                tester.Run(invoker1, 0, 0, B_BAD_PORT_ID, false, false, 0);
#endif
                tester.Run(invoker2, 0, 0, B_BAD_PORT_ID, false, false, 0);
        }
        // status_t SendMessage(BMessage *message, BMessage *reply,
        //                                              bigtime_t deliveryTimeout,
        //                                              bigtime_t replyTimeout) const
        NextSubTest();
        {
                SMInvoker5 invoker1(true, false, B_INFINITE_TIMEOUT,
                                                        B_INFINITE_TIMEOUT);
                SMInvoker5 invoker2(true, true, B_INFINITE_TIMEOUT,
                                                        B_INFINITE_TIMEOUT);
#ifdef TEST_OBOS
                tester.Run(invoker1, 0, 0, B_BAD_VALUE, false, false, 0);
#else
                tester.Run(invoker1, 0, 0, B_BAD_PORT_ID, false, false, 0);
#endif
                tester.Run(invoker2, 0, 0, B_BAD_PORT_ID, false, false, 0);
        }
}

// TestInitialized
void
SendMessageTester::TestInitialized(SMTester &tester)
{
        // status_t SendMessage(uint32 command, BHandler *replyTo) const
        NextSubTest();
        {
                SMInvoker1 invoker1(false);
                SMInvoker1 invoker2(true);
                tester.Run(invoker1, 0, 0, B_OK, true, false, 0);
                tester.Run(invoker2, 0, 0, B_OK, true, true, 0);
        }
        // status_t SendMessage(BMessage *message, BHandler *replyTo,
        //                                              bigtime_t timeout) const
        NextSubTest();
        {
// R5 crashes when passing a NULL message.
#ifndef TEST_R5
                SMInvoker2 invoker1(false, false, B_INFINITE_TIMEOUT);
                tester.Run(invoker1, 0, 0, B_BAD_VALUE, false, false, 0);
#endif
        }
        NextSubTest();
        {
                SMInvoker2 invoker1(true, false, B_INFINITE_TIMEOUT);
                SMInvoker2 invoker2(true, true, B_INFINITE_TIMEOUT);
                tester.Run(invoker1, 0, 0, B_OK, true, false, 0);
                tester.Run(invoker2, 0, 0, B_OK, true, true, 0);
        }
        NextSubTest();
        {
                SMInvoker2 invoker1(true, false, 0);
                SMInvoker2 invoker2(true, true, 0);
                tester.Run(invoker1, 0, 0, B_OK, true, false, 0);
                tester.Run(invoker2, 0, 0, B_OK, true, true, 0);
                tester.Run(invoker1, 20000, 0, B_WOULD_BLOCK, false, false, 0);
                tester.Run(invoker2, 20000, 0, B_WOULD_BLOCK, false, false, 0);
        }
        NextSubTest();
        {
                SMInvoker2 invoker1(true, false, 20000);
                SMInvoker2 invoker2(true, true, 20000);
                tester.Run(invoker1, 10000, 0, B_OK, true, false, 10000);
                tester.Run(invoker2, 10000, 0, B_OK, true, true, 10000);
                tester.Run(invoker1, 40000, 0, B_TIMED_OUT, false, false, 20000);
                tester.Run(invoker2, 40000, 0, B_TIMED_OUT, false, false, 20000);
        }
        // status_t SendMessage(BMessage *message, BMessenger replyTo,
        //                                              bigtime_t timeout) const
        NextSubTest();
        {
// R5 crashes when passing a NULL message.
#ifndef TEST_R5
                SMInvoker3 invoker1(false, false, B_INFINITE_TIMEOUT);
                tester.Run(invoker1, 0, 0, B_BAD_VALUE, false, false, 0);
#endif
        }
        NextSubTest();
        {
                SMInvoker3 invoker1(true, false, B_INFINITE_TIMEOUT);
                SMInvoker3 invoker2(true, true, B_INFINITE_TIMEOUT);
                tester.Run(invoker1, 0, 0, B_OK, true, false, 0);
                tester.Run(invoker2, 0, 0, B_OK, true, true, 0);
        }
        NextSubTest();
        {
                SMInvoker3 invoker1(true, false, 0);
                SMInvoker3 invoker2(true, true, 0);
                tester.Run(invoker1, 0, 0, B_OK, true, false, 0);
                tester.Run(invoker2, 0, 0, B_OK, true, true, 0);
                tester.Run(invoker1, 20000, 0, B_WOULD_BLOCK, false, false, 0);
                tester.Run(invoker2, 20000, 0, B_WOULD_BLOCK, false, false, 0);
        }
        NextSubTest();
        {
                SMInvoker3 invoker1(true, false, 20000);
                SMInvoker3 invoker2(true, true, 20000);
                tester.Run(invoker1, 10000, 0, B_OK, true, false, 10000);
                tester.Run(invoker2, 10000, 0, B_OK, true, true, 10000);
                tester.Run(invoker1, 40000, 0, B_TIMED_OUT, false, false, 20000);
                tester.Run(invoker2, 40000, 0, B_TIMED_OUT, false, false, 20000);
        }
        // status_t SendMessage(uint32 command, BMessage *reply) const
        NextSubTest();
        {
// R5 crashes when passing a NULL reply message
#ifndef TEST_R5
                SMInvoker4 invoker1(false);
#endif
                SMInvoker4 invoker2(true);
#ifndef TEST_R5
                tester.Run(invoker1, 20000, 20000, B_BAD_VALUE, false, false, 0);
#endif
                tester.Run(invoker2, 20000, 20000, B_OK, true, true, 40000);
        }
        // status_t SendMessage(BMessage *message, BMessage *reply,
        //                                              bigtime_t deliveryTimeout,
        //                                              bigtime_t replyTimeout) const
        NextSubTest();
        {
// R5 crashes when passing a NULL message.
#ifndef TEST_R5
                SMInvoker5 invoker1(false, true, B_INFINITE_TIMEOUT,
                                                        B_INFINITE_TIMEOUT);
                tester.Run(invoker1, 0, 0, B_BAD_VALUE, false, false, 0);
#endif
        }
        NextSubTest();
        {
                SMInvoker5 invoker1(true, true, B_INFINITE_TIMEOUT,
                                                        B_INFINITE_TIMEOUT);
                SMInvoker5 invoker2(true, true, B_INFINITE_TIMEOUT, 0);
                SMInvoker5 invoker3(true, true, B_INFINITE_TIMEOUT, 20000);
                tester.Run(invoker1, 0, 0, B_OK, true, true, 0);
                tester.Run(invoker1, 10000, 0, B_OK, true, true, 10000);
                tester.Run(invoker1, 0, 10000, B_OK, true, true, 10000);
                // These two are race-conditional: The sending task must be pre-empted
                // before reading from the reply port and the target must reply before
                // the sending task gets another time slice.
//              tester.Run(invoker2, 0, 0, B_OK, true, true, 0);
//              tester.Run(invoker2, 10000, 0, B_OK, true, true, 10000);
                tester.Run(invoker2, 0, 10000, B_WOULD_BLOCK, true, false, 0);
                tester.Run(invoker3, 0, 10000, B_OK, true, true, 10000);
                tester.Run(invoker3, 20000, 10000, B_OK, true, true, 30000);
                tester.Run(invoker3, 0, 30000, B_TIMED_OUT, true, false, 20000);
        }
        NextSubTest();
        {
                SMInvoker5 invoker1(true, true, 0, B_INFINITE_TIMEOUT);
                SMInvoker5 invoker2(true, true, 0, 0);
                SMInvoker5 invoker3(true, true, 0, 20000);
                tester.Run(invoker1, 0, 0, B_OK, true, true, 0);
                tester.Run(invoker1, 10000, 0, B_WOULD_BLOCK, false, false, 0);
                tester.Run(invoker1, 0, 10000, B_OK, true, true, 10000);
                // This one is race-conditional: The sending task must be pre-empted
                // before reading from the reply port and the target must reply before
                // the sending task gets another time slice.
//              tester.Run(invoker2, 0, 0, B_OK, true, true, 0);
                tester.Run(invoker2, 10000, 0, B_WOULD_BLOCK, false, false, 0);
                tester.Run(invoker2, 0, 10000, B_WOULD_BLOCK, true, false, 0);
                tester.Run(invoker3, 0, 10000, B_OK, true, true, 10000);
                tester.Run(invoker3, 10000, 10000, B_WOULD_BLOCK, false, false, 0);
                tester.Run(invoker3, 0, 30000, B_TIMED_OUT, true, false, 20000);
        }
        NextSubTest();
        {
                SMInvoker5 invoker1(true, true, 20000, B_INFINITE_TIMEOUT);
                SMInvoker5 invoker2(true, true, 20000, 0);
                SMInvoker5 invoker3(true, true, 20000, 20000);
                tester.Run(invoker1, 0, 0, B_OK, true, true, 0);
                tester.Run(invoker1, 10000, 0, B_OK, true, true, 10000);
                tester.Run(invoker1, 30000, 0, B_TIMED_OUT, false, false, 20000);
                tester.Run(invoker1, 10000, 20000, B_OK, true, true, 30000);
                // These two are race-conditional: The sending task must be pre-empted
                // before reading from the reply port and the target must reply before
                // the sending task gets another time slice.
//              tester.Run(invoker2, 0, 0, B_OK, true, true, 0);
//              tester.Run(invoker2, 10000, 0, B_OK, true, true, 0);
                tester.Run(invoker2, 30000, 0, B_TIMED_OUT, false, false, 20000);
                tester.Run(invoker2, 0, 10000, B_WOULD_BLOCK, true, false, 0);
                tester.Run(invoker3, 10000, 10000, B_OK, true, true, 20000);
                tester.Run(invoker3, 30000, 10000, B_TIMED_OUT, false, false, 20000);
                tester.Run(invoker3, 10000, 30000, B_TIMED_OUT, true, false, 30000);
        }
}

/*
        The different SendMessage() flavors.
 */
void SendMessageTester::SendMessageTest1()
{
        TestUninitialized();
        target_kind targetKinds[] = {
                TARGET_LOCAL_PREFERRED,
                TARGET_LOCAL_SPECIFIC,
                TARGET_REMOTE_PREFERRED,
                TARGET_REMOTE_SPECIFIC
        };
        int32 targetKindCount = sizeof(targetKinds) / sizeof(target_kind);
        for (int32 i = 0; i < targetKindCount; i++) {
                SMTester tester(targetKinds[i]);
                TestInitialized(tester);
        }
}


Test* SendMessageTester::Suite()
{
        typedef BThreadedTestCaller<SendMessageTester> TC;

        TestSuite* testSuite = new TestSuite;

        ADD_TEST4(BMessenger, testSuite, SendMessageTester, SendMessageTest1);

        return testSuite;
}