//------------------------------------------------------------------------------
//      SetNextHandlerTest.cpp
//
//------------------------------------------------------------------------------

// Standard Includes -----------------------------------------------------------

// System Includes -------------------------------------------------------------
#include <Looper.h>

// Project Includes ------------------------------------------------------------

// Local Includes --------------------------------------------------------------
#include "SetNextHandlerTest.h"

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

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

//------------------------------------------------------------------------------
/**
        SetNextHandler(BHandler* handler);
        NextHandler();
        @case                   Clear the next handler
        @param  handler Valid BHandler pointer, then NULL
        @results                NextHandler() returns Handler2, then NULL
 */
void TSetNextHandlerTest::SetNextHandler0()
{
        BLooper Looper;
        BHandler Handler1;
        BHandler Handler2;

        Looper.AddHandler(&Handler1);
        Looper.AddHandler(&Handler2);

        Handler1.SetNextHandler(&Handler2);
        CPPUNIT_ASSERT(Handler1.NextHandler() == &Handler2);

        Handler1.SetNextHandler(NULL);
        CPPUNIT_ASSERT(!Handler1.NextHandler());
}
//------------------------------------------------------------------------------
/**
        SetNextHandler(BHandler* handler);
        NextHandler();
        @case                   Handler1 and Handler2 do not belong to a BLooper
        @param  handler Valid BHandler pointer
        @results                NextHandler() returns NULL
                                        debug message "handler must belong to looper before setting
                                        NextHandler"
 */
void TSetNextHandlerTest::SetNextHandler1()
{
        DEBUGGER_ESCAPE;

        BHandler Handler1;
        BHandler Handler2;
        Handler1.SetNextHandler(&Handler2);
        CPPUNIT_ASSERT(Handler1.NextHandler() == NULL);
}
//------------------------------------------------------------------------------
/**
        SetNextHandler(BHandler* handler);
        NextHandler();
        @case                   Handler1 belongs to a unlocked BLooper, Handler2 does not
        @param  handler Valid BHandler pointer
        @results                NextHandler() returns BLooper
                                        debug message "The handler's looper must be locked before
                                        setting NextHandler"
 */
void TSetNextHandlerTest::SetNextHandler2()
{
        DEBUGGER_ESCAPE;

        BHandler Handler1;
        BHandler Handler2;
        BLooper Looper;
        Looper.AddHandler(&Handler1);
        Looper.Unlock();
        Handler1.SetNextHandler(&Handler2);
        CPPUNIT_ASSERT(Handler1.NextHandler() == &Looper);
}
//------------------------------------------------------------------------------
/**
        SetNextHandler(BHandler* handler);
        NextHandler();
        @case                   Handler1 belongs to a locked BLooper, Handler2 does not
        @param  handler Valid BHandler pointer
        @results                NextHandler() returns BLooper
                                        debug message "The handler and its NextHandler must have
                                        the same looper"
 */
void TSetNextHandlerTest::SetNextHandler3()
{
        DEBUGGER_ESCAPE;

        BHandler Handler1;
        BHandler Handler2;
        BLooper Looper;
        Looper.AddHandler(&Handler1);
        Handler1.SetNextHandler(&Handler2);
        CPPUNIT_ASSERT(Handler1.NextHandler() == &Looper);
}
//------------------------------------------------------------------------------
/**
        SetNextHandler(BHandler* handler);
        NextHandler();
        @case                   Handler2 belongs to a unlocked BLooper, Handler1 does not
        @param  handler Valid BHandler pointer
        @results                NextHandler() returns NULL
                                        debug message "handler must belong to looper before setting
                                        NextHandler"
 */
void TSetNextHandlerTest::SetNextHandler4()
{
        DEBUGGER_ESCAPE;

        BHandler Handler1;
        BHandler Handler2;
        BLooper Looper;
        Looper.AddHandler(&Handler2);
        Looper.Unlock();
        Handler1.SetNextHandler(&Handler2);
        CPPUNIT_ASSERT(Handler1.NextHandler() == NULL);
}
//------------------------------------------------------------------------------
/**
        SetNextHandler(BHandler* handler);
        NextHandler();
        @case                   Handler2 belongs to a locked BLooper, Handler1 does not
        @param  handler Valid BHandler pointer
        @results                NextHandler() returns NULL
                                        debug message "handler must belong to looper before setting
                                        NextHandler"
 */
void TSetNextHandlerTest::SetNextHandler5()
{
        DEBUGGER_ESCAPE;

        BHandler Handler1;
        BHandler Handler2;
        BLooper Looper;
        Looper.AddHandler(&Handler2);
        Handler1.SetNextHandler(&Handler2);
        CPPUNIT_ASSERT(Handler1.NextHandler() == NULL);
}
//------------------------------------------------------------------------------
/**
        SetNextHandler(BHandler* handler);
        NextHandler();
        @case                   Handler1 and Handler2 belong to different unlocked BLoopers
        @param  handler Valid BHandler pointer
        @results                Returns BLooper;
                                        debug message "The handler and its NextHandler must have the
                                        same looper"
 */
void TSetNextHandlerTest::SetNextHandler6()
{
        DEBUGGER_ESCAPE;

        BHandler Handler1;
        BHandler Handler2;
        BLooper Looper1;
        BLooper Looper2;
        Looper1.AddHandler(&Handler1);
        Looper2.AddHandler(&Handler2);
        Looper1.Unlock();
        Looper2.Unlock();
        Handler1.SetNextHandler(&Handler2);
        CPPUNIT_ASSERT(Handler1.NextHandler() == &Looper1);
}
//------------------------------------------------------------------------------
/**
        SetNextHandler(BHandler* handler);
        NextHandler();
        @case                   Handler1 and Handler2 belong to different BLoopers;
                                        Handler1's is locked; Handler2's is not
        @param  handler Valid BHandler pointer
        @result                 Returns BLooper;
                                        debug message "The handler and its NextHandler must have the
                                        same looper"
 */
void TSetNextHandlerTest::SetNextHandler7()
{
        DEBUGGER_ESCAPE;

        BHandler Handler1;
        BHandler Handler2;
        BLooper Looper1;
        BLooper Looper2;
        Looper1.AddHandler(&Handler1);
        Looper2.AddHandler(&Handler2);
        Looper2.Unlock();
        Handler1.SetNextHandler(&Handler2);
        CPPUNIT_ASSERT(Handler1.NextHandler() == &Looper1);
}
//------------------------------------------------------------------------------
/**
        SetNextHandler(BHandler* handler);
        NextHandler();
        @case                   Handler1 and Handler2 belong to different BLoopers;
                                        Handler1's is unlocked; Handler2's is locked
        @param  handler Valid BHandler pointer
        @results                Returns BLooper
                                        debug message "The handler and its NextHandler must have the
                                        same looper"
 */
void TSetNextHandlerTest::SetNextHandler8()
{
        DEBUGGER_ESCAPE;

        BHandler Handler1;
        BHandler Handler2;
        BLooper Looper1;
        BLooper Looper2;
        Looper1.AddHandler(&Handler1);
        Looper2.AddHandler(&Handler2);
        Looper1.Unlock();
        Handler1.SetNextHandler(&Handler2);
        CPPUNIT_ASSERT(Handler1.NextHandler() == &Looper1);
}
//------------------------------------------------------------------------------
/**
        SetNextHandler(BHandler* handler);
        NextHandler();
        @case                   Handler1 and Handler2 belong to different locked BLoopers
        @param  handler Valid BHandler pointer
        @results                Returns BLooper
                                        debug message "The handler and its NextHandler must have the
                                        same looper"
 */
void TSetNextHandlerTest::SetNextHandler9()
{
        DEBUGGER_ESCAPE;

        BHandler Handler1;
        BHandler Handler2;
        BLooper Looper1;
        BLooper Looper2;
        Looper1.AddHandler(&Handler1);
        Looper2.AddHandler(&Handler2);
        Handler1.SetNextHandler(&Handler2);
        CPPUNIT_ASSERT(Handler1.NextHandler() == &Looper1);
}
//------------------------------------------------------------------------------
/**
        SetNextHandler(BHandler* handler);
        NextHandler();
        @case                   Handler1 and Handler2 belong to the same unlocked BLooper
        @param  handler Valid BHandler pointer
        @results                Returns Handler2
                                        debug message "The handler's looper must be locked before
                                        setting NextHandler"
        @note                   R5 implementation allows the next handler to be set anyway;
                                        we do the same.
 */
void TSetNextHandlerTest::SetNextHandler10()
{
        DEBUGGER_ESCAPE;

        BLooper Looper;
        BHandler Handler1;
        BHandler Handler2;
        Looper.AddHandler(&Handler1);
        Looper.AddHandler(&Handler2);
        Looper.Unlock();
        Handler1.SetNextHandler(&Handler2);
        CPPUNIT_ASSERT(Handler1.NextHandler() == &Looper);
}
//------------------------------------------------------------------------------
/**
        SetNextHandler(BHandler* handler);
        NextHandler();
        @case                   Handler1 and Handler2 belong to the same locked BLooper
        @param  handler Valid BHandler pointer
        @results                Returns Handler2
 */
void TSetNextHandlerTest::SetNextHandler11()
{
        BLooper Looper;
        BHandler Handler1;
        BHandler Handler2;
        Looper.AddHandler(&Handler1);
        Looper.AddHandler(&Handler2);
        Handler1.SetNextHandler(&Handler2);
        CPPUNIT_ASSERT(Handler1.NextHandler() == &Handler2);
}
//------------------------------------------------------------------------------
Test* TSetNextHandlerTest::Suite()
{
        TestSuite* SuiteOfTests = new TestSuite("BHandler::SetNextHandler");

        ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler0);
        ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler1);
        ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler2);
        ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler3);
        ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler4);
        ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler5);
        ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler6);
        ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler7);
        ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler8);
        ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler9);
        ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler10);
        ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler11);

        return SuiteOfTests;
}
//------------------------------------------------------------------------------

/*
 * $Log $
 *
 * $Id  $
 *
 */