//------------------------------------------------------------------------------
//      LockTargetWithTimeoutTester.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 "LockTargetWithTimeoutTester.h"
#include "SMTarget.h"

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

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

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

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

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

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

/*
        status_t LockTargetWithTimeout(bigtime_t timeout) const
        @case 1                 this is uninitialized
        @results                should return B_BAD_VALUE.
 */
void LockTargetWithTimeoutTester::LockTargetWithTimeoutTest1()
{
        BMessenger messenger;
        CHK(messenger.LockTargetWithTimeout(0) == B_BAD_VALUE);
}

/*
        status_t LockTargetWithTimeout(bigtime_t timeout) const
        @case 2                 this is initialized to local target with preferred handler,
                                        looper is not locked
        @results                should lock the looper and return B_OK.
 */
void LockTargetWithTimeoutTester::LockTargetWithTimeoutTest2()
{
        status_t result = B_OK;
        BLooper *looper = new BLooper;
        looper->Run();
        LooperQuitter quitter(looper);
        BMessenger messenger(NULL, looper, &result);
        CHK(messenger.LockTargetWithTimeout(0) == B_OK);
        CHK(looper->IsLocked() == true);
        looper->Unlock();
        CHK(looper->IsLocked() == false);
}

/*
        status_t LockTargetWithTimeout(bigtime_t timeout) const
        @case 3                 this is initialized to local target with specific handler,
                                        looper is not locked
        @results                should lock the looper and return B_OK.
 */
void LockTargetWithTimeoutTester::LockTargetWithTimeoutTest3()
{
        // create looper and handler
        status_t result = B_OK;
        BLooper *looper = new BLooper;
        looper->Run();
        LooperQuitter quitter(looper);
        BHandler *handler = new BHandler;
        HandlerDeleter deleter(handler);
        CHK(looper->Lock());
        looper->AddHandler(handler);
        looper->Unlock();
        // create the messenger and do the checks
        BMessenger messenger(handler, NULL, &result);
        CHK(messenger.LockTargetWithTimeout(0) == B_OK);
        CHK(looper->IsLocked() == true);
        looper->Unlock();
        CHK(looper->IsLocked() == false);
}

/*
        status_t LockTargetWithTimeout(bigtime_t timeout) const
        @case 4                 this is initialized to local target with preferred handler,
                                        looper is locked by another thread, timeout is 100ms
        @results                should block until the looper is unlocked (after 50ms),
                                        lock it and return B_OK.
        @thread A               - locks the looper
                                        - waits 100ms
                                        - unlocks the looper
 */
void LockTargetWithTimeoutTester::LockTargetWithTimeoutTest4A()
{
        CHK(fLooper->Lock() == true);
        snooze(100000);
        fLooper->Unlock();
}

/*
        status_t LockTargetWithTimeout(bigtime_t timeout) const
        @case 4                 this is initialized to local target with preferred handler,
                                        looper is locked by another thread, timeout is 100ms
        @results                should block until the looper is unlocked (after 50ms),
                                        lock it and return B_OK.
        @thread B               - waits 50ms (until thread A has acquired the looper lock)
                                        - tries to lock the looper via messenger and blocks
                                        - acquires the lock successfully after 50ms
                                        - unlocks the looper
 */
void LockTargetWithTimeoutTester::LockTargetWithTimeoutTest4B()
{
        enum { JITTER = 10000 };        // Maybe critical on slow machines.
        snooze(50000);
        BMessenger messenger(NULL, fLooper);
        bigtime_t time = system_time();
        CHK(messenger.LockTargetWithTimeout(100000) == B_OK);
        time = system_time() - time - 50000;
        CHK(fLooper->IsLocked() == true);
        fLooper->Unlock();
        CHK(fLooper->IsLocked() == false);
        CHK(time > -JITTER && time < JITTER);
}

/*
        status_t LockTargetWithTimeout(bigtime_t timeout) const
        @case 5                 this is initialized to local target with preferred handler,
                                        looper is locked by another thread, timeout is 25ms
        @results                should block for 25ms, not until the looper is unlocked
                                        (after 50ms), should return B_TIMED_OUT.
        @thread A               - locks the looper
                                        - waits 100ms
                                        - unlocks the looper
 */
void LockTargetWithTimeoutTester::LockTargetWithTimeoutTest5A()
{
        CHK(fLooper->Lock() == true);
        snooze(100000);
        fLooper->Unlock();
}

/*
        status_t LockTargetWithTimeout(bigtime_t timeout) const
        @case 5                 this is initialized to local target with preferred handler,
                                        looper is locked by another thread, timeout is 25ms
        @results                should block for 25ms, not until the looper is unlocked
                                        (after 50ms), should return B_TIMED_OUT.
        @thread B               - waits 50ms (until thread A has acquired the looper lock)
                                        - tries to lock the looper via messenger and blocks
                                        - times out after 25ms
 */
void LockTargetWithTimeoutTester::LockTargetWithTimeoutTest5B()
{
        enum { JITTER = 10000 };        // Maybe critical on slow machines.
        snooze(50000);
        BMessenger messenger(NULL, fLooper);
        bigtime_t time = system_time();
        CHK(messenger.LockTargetWithTimeout(25000) == B_TIMED_OUT);
        time = system_time() - time - 25000;
        CHK(fLooper->IsLocked() == false);
        CHK(time > -JITTER && time < JITTER);
}

/*
        status_t LockTargetWithTimeout(bigtime_t timeout) const
        @case 6                 this is initialized to local target with specific handler,
                                        looper is locked by another thread, timeout is 100ms
        @results                should block until the looper is unlocked (after 50ms),
                                        lock it and return B_OK.
        @thread A               - locks the looper
                                        - waits 100ms
                                        - unlocks the looper
 */
void LockTargetWithTimeoutTester::LockTargetWithTimeoutTest6A()
{
        CHK(fLooper->Lock() == true);
        snooze(100000);
        fLooper->Unlock();
}

/*
        status_t LockTargetWithTimeout(bigtime_t timeout) const
        @case 6                 this is initialized to local target with specific handler,
                                        looper is locked by another thread, timeout is 100ms
        @results                should block until the looper is unlocked (after 50ms),
                                        lock it and return B_OK.
        @thread B               - waits 50ms (until thread A has acquired the looper lock)
                                        - tries to lock the looper via messenger and blocks
                                        - acquires the lock successfully after 50ms
                                        - unlocks the looper
 */
void LockTargetWithTimeoutTester::LockTargetWithTimeoutTest6B()
{
        enum { JITTER = 10000 };        // Maybe critical on slow machines.
        snooze(50000);
        BMessenger messenger(fHandler, NULL);
        bigtime_t time = system_time();
        CHK(messenger.LockTargetWithTimeout(100000) == B_OK);
        time = system_time() - time - 50000;
        CHK(fLooper->IsLocked() == true);
        fLooper->Unlock();
        CHK(fLooper->IsLocked() == false);
        CHK(time > -JITTER && time < JITTER);
}

/*
        status_t LockTargetWithTimeout(bigtime_t timeout) const
        @case 7                 this is initialized to local target with specific handler,
                                        looper is locked by another thread, timeout is 25ms
        @results                should block for 25ms, not until the looper is unlocked
                                        (after 50ms), should return B_TIMED_OUT.
        @thread A               - locks the looper
                                        - waits 100ms
                                        - unlocks the looper
 */
void LockTargetWithTimeoutTester::LockTargetWithTimeoutTest7A()
{
        CHK(fLooper->Lock() == true);
        snooze(100000);
        fLooper->Unlock();
}

/*
        status_t LockTargetWithTimeout(bigtime_t timeout) const
        @case 7                 this is initialized to local target with specific handler,
                                        looper is locked by another thread, timeout is 25ms
        @results                should block for 25ms, not until the looper is unlocked
                                        (after 50ms), should return B_TIMED_OUT.
        @thread B               - waits 50ms (until thread A has acquired the looper lock)
                                        - tries to lock the looper via messenger and blocks
                                        - times out after 25ms
 */
void LockTargetWithTimeoutTester::LockTargetWithTimeoutTest7B()
{
        enum { JITTER = 10000 };        // Maybe critical on slow machines.
        snooze(50000);
        BMessenger messenger(fHandler, NULL);
        bigtime_t time = system_time();
        CHK(messenger.LockTargetWithTimeout(25000) == B_TIMED_OUT);
        time = system_time() - time - 25000;
        CHK(fLooper->IsLocked() == false);
        CHK(time > -JITTER && time < JITTER);
}

/*
        status_t LockTargetWithTimeout(bigtime_t timeout) const
        @case 8                 this is initialized to remote target with preferred
                                        handler, looper is not locked
        @results                should not lock the looper and return B_BAD_VALUE.
 */
void LockTargetWithTimeoutTester::LockTargetWithTimeoutTest8()
{
        RemoteSMTarget target(true);
        BMessenger messenger(target.Messenger());
        CHK(messenger.LockTargetWithTimeout(10000) == B_BAD_VALUE);
}

/*
        status_t LockTargetWithTimeout(bigtime_t timeout) const
        @case 9                 this is initialized to remote target with specific handler,
                                        looper is not locked
        @results                should not lock the looper and return B_BAD_VALUE.
 */
void LockTargetWithTimeoutTester::LockTargetWithTimeoutTest9()
{
        RemoteSMTarget target(false);
        BMessenger messenger(target.Messenger());
        CHK(messenger.LockTargetWithTimeout(10000) == B_BAD_VALUE);
}


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

        TestSuite* testSuite = new TestSuite;

        ADD_TEST4(BMessenger, testSuite, LockTargetWithTimeoutTester,
                         LockTargetWithTimeoutTest1);
        ADD_TEST4(BMessenger, testSuite, LockTargetWithTimeoutTester,
                         LockTargetWithTimeoutTest2);
        ADD_TEST4(BMessenger, testSuite, LockTargetWithTimeoutTester,
                         LockTargetWithTimeoutTest3);
        // test4
        LockTargetWithTimeoutTester *test4
                = new LockTargetWithTimeoutTester("LockTargetWithTimeoutTest4");
        test4->fLooper = new BLooper;
        test4->fLooper->Run();
        // test4 test caller
        TC *caller4 = new TC("BMessenger::LockTargetWithTimeoutTest4", test4);
        caller4->addThread("A",
                &LockTargetWithTimeoutTester::LockTargetWithTimeoutTest4A);
        caller4->addThread("B",
                &LockTargetWithTimeoutTester::LockTargetWithTimeoutTest4B);
        testSuite->addTest(caller4);    
        // test5
        LockTargetWithTimeoutTester *test5
                = new LockTargetWithTimeoutTester("LockTargetWithTimeoutTest5");
        test5->fLooper = new BLooper;
        test5->fLooper->Run();
        // test5 test caller
        TC *caller5 = new TC("BMessenger::LockTargetWithTimeoutTest5", test5);
        caller5->addThread("A",
                &LockTargetWithTimeoutTester::LockTargetWithTimeoutTest5A);
        caller5->addThread("B",
                &LockTargetWithTimeoutTester::LockTargetWithTimeoutTest5B);
        testSuite->addTest(caller5);    
        // test6
        LockTargetWithTimeoutTester *test6
                = new LockTargetWithTimeoutTester("LockTargetWithTimeoutTest6");
        // create looper and handler
        test6->fLooper = new BLooper;
        test6->fLooper->Run();
        test6->fHandler = new BHandler;
        if (test6->fLooper->Lock()) {
                test6->fLooper->AddHandler(test6->fHandler);
                test6->fLooper->Unlock();
        } else
                printf("ERROR: Can't init LockTargetWithTimeoutTester test6!\n");
        // test6 test caller
        TC *caller6 = new TC("BMessenger::LockTargetWithTimeoutTest6", test6);
        caller6->addThread("A",
                &LockTargetWithTimeoutTester::LockTargetWithTimeoutTest6A);
        caller6->addThread("B",
                &LockTargetWithTimeoutTester::LockTargetWithTimeoutTest6B);
        testSuite->addTest(caller6);    
        // test7
        LockTargetWithTimeoutTester *test7
                = new LockTargetWithTimeoutTester("LockTargetWithTimeoutTest7");
        // create looper and handler
        test7->fLooper = new BLooper;
        test7->fLooper->Run();
        test7->fHandler = new BHandler;
        if (test7->fLooper->Lock()) {
                test7->fLooper->AddHandler(test7->fHandler);
                test7->fLooper->Unlock();
        } else
                printf("ERROR: Can't init LockTargetWithTimeoutTester test7!\n");
        // test7 test caller
        TC *caller7 = new TC("BMessenger::LockTargetWithTimeoutTest7", test7);
        caller7->addThread("A",
                &LockTargetWithTimeoutTester::LockTargetWithTimeoutTest7A);
        caller7->addThread("B",
                &LockTargetWithTimeoutTester::LockTargetWithTimeoutTest7B);
        testSuite->addTest(caller7);    
        // tests 8-9
        ADD_TEST4(BMessenger, testSuite, LockTargetWithTimeoutTester,
                         LockTargetWithTimeoutTest8);
        ADD_TEST4(BMessenger, testSuite, LockTargetWithTimeoutTester,
                         LockTargetWithTimeoutTest9);

        return testSuite;
}