/*

* Copyright (c) 2006-2006 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:    TGlxFromFocusOutwardIterator unit tests

*

*/

#include <digia/eunit/eunitmacros.h>

#include "t_glxfromfocusoutwarditerator.h"

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

// NewL

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

//

T_CGlxFromFocusOutwardIterator* T_CGlxFromFocusOutwardIterator::NewL()

    {

    T_CGlxFromFocusOutwardIterator* self = T_CGlxFromFocusOutwardIterator::NewLC();

    CleanupStack::Pop();

    return self;

    }

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

// NewLC

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

//

T_CGlxFromFocusOutwardIterator* T_CGlxFromFocusOutwardIterator::NewLC()

    {

    T_CGlxFromFocusOutwardIterator* self = new( ELeave ) T_CGlxFromFocusOutwardIterator();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

T_CGlxFromFocusOutwardIterator::~T_CGlxFromFocusOutwardIterator()

    {

    }

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

// Constructor

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

//

T_CGlxFromFocusOutwardIterator::T_CGlxFromFocusOutwardIterator()

    {

    }

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

// Constructor

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

//

void T_CGlxFromFocusOutwardIterator::ConstructL()

    {

    // The ConstructL from the base class CEUnitTestSuiteClass must be called.

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

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

// Setup

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

//

void T_CGlxFromFocusOutwardIterator::SetupL(  )

    {

    iOrder = &iFocusOrder;

    iList.iCount = 0;

    iList.iFocusIndex = -1;

    iOrder->SetToFirst(&iList);

    iFocusOrder.SetRangeOffsets(0, 0);

    }

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

// Teardown

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

//

void T_CGlxFromFocusOutwardIterator::Teardown(  )

    {

    } 

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

// UT_TestEmptyL

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

//

void T_CGlxFromFocusOutwardIterator::UT_TestEmptyL(  )

    {

    EUNIT_ASSERT(iFocusOrder.iCurrentItem == 0 && iFocusOrder.iFrontOffset == 0 && 

    	iFocusOrder.iRearOffset == 0 && iFocusOrder.iList == &iList);

	TInt index;

	// Test with empty list

	index = (*iOrder)++;

    EUNIT_ASSERT(iFocusOrder.iCurrentItem == 0 && index == KErrNotFound);

    EUNIT_ASSERT(iFocusOrder.iFrontOffset == 0 && iFocusOrder.iRearOffset == 0 && iFocusOrder.iList == &iList);

	index = (*iOrder)++;

    EUNIT_ASSERT(iFocusOrder.iCurrentItem == 0 && index == KErrNotFound);

	// Test with a range

    iOrder->SetToFirst(&iList); // (Does nothing)

    iFocusOrder.SetRangeOffsets(1, 1);

	index = (*iOrder)++;

    EUNIT_ASSERT(iFocusOrder.iCurrentItem == 0 && index == KErrNotFound);

    EUNIT_ASSERT(iFocusOrder.iFrontOffset == 1 && iFocusOrder.iRearOffset == 1 && iFocusOrder.iList == &iList);

	index = (*iOrder)++;

    EUNIT_ASSERT(iFocusOrder.iCurrentItem == 0 && index == KErrNotFound);    

	// Test with a range

    iOrder->SetToFirst(&iList); // (Does nothing)

    iFocusOrder.SetRangeOffsets(4, 0);

	index = (*iOrder)++;

    EUNIT_ASSERT(iFocusOrder.iCurrentItem == 0 && index == KErrNotFound);

    EUNIT_ASSERT(iFocusOrder.iFrontOffset == 0 && iFocusOrder.iRearOffset == 4 && iFocusOrder.iList == &iList);

	index = (*iOrder)++;

    EUNIT_ASSERT(iFocusOrder.iCurrentItem == 0 && index == KErrNotFound);    

	// Test with a range

    iOrder->SetToFirst(&iList); // (Does nothing)

    iFocusOrder.SetRangeOffsets(0, 5);

	index = (*iOrder)++;

    EUNIT_ASSERT(iFocusOrder.iCurrentItem == 0 && index == KErrNotFound);

    EUNIT_ASSERT(iFocusOrder.iFrontOffset == 5 && iFocusOrder.iRearOffset == 0 && iFocusOrder.iList == &iList);

	index = (*iOrder)++;

    EUNIT_ASSERT(iFocusOrder.iCurrentItem == 0 && index == KErrNotFound);    

    }

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

// UT_TestSymmetricRangeL

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

//

void T_CGlxFromFocusOutwardIterator::UT_TestSymmetricRangeL(  )

	{

    EUNIT_ASSERT(iFocusOrder.iCurrentItem == 0 && iFocusOrder.iFrontOffset == 0 && 

    	iFocusOrder.iRearOffset == 0 && iFocusOrder.iList == &iList);

	TInt index;

	// Test with a list with 1 item, no range

    iList.iCount = 1; 

    iList.iFocusIndex = 0;

	index = (*iOrder)++;

    EUNIT_ASSERT(iFocusOrder.iCurrentItem == 1 && index == 0);

    EUNIT_ASSERT(iFocusOrder.iFrontOffset == 0 && iFocusOrder.iRearOffset == 0 && iFocusOrder.iList == &iList);

	index = (*iOrder)++;

    EUNIT_ASSERT(iFocusOrder.iCurrentItem == 1 && index == KErrNotFound);

    EUNIT_ASSERT(iFocusOrder.iFrontOffset == 0 && iFocusOrder.iRearOffset == 0 && iFocusOrder.iList == &iList);

	// Test with a list with 2 items, no range

    iOrder->SetToFirst(&iList); 

    iList.iCount = 2;

    iList.iFocusIndex = 0; 

	index = (*iOrder)++;

    EUNIT_ASSERT(iFocusOrder.iCurrentItem == 1 && index == 0);

	index = (*iOrder)++;

    EUNIT_ASSERT(iFocusOrder.iCurrentItem == 1 && index == KErrNotFound);

 	index = (*iOrder)++;

    EUNIT_ASSERT(iFocusOrder.iCurrentItem == 1 && index == KErrNotFound);

	// Focus to 1   

    iOrder->SetToFirst(&iList); 

    iList.iFocusIndex = 1;

	index = (*iOrder)++;

    EUNIT_ASSERT(iFocusOrder.iCurrentItem == 1 && index == 1);

	index = (*iOrder)++;

    EUNIT_ASSERT(iFocusOrder.iCurrentItem == 1 && index == KErrNotFound);

 	index = (*iOrder)++;

    EUNIT_ASSERT(iFocusOrder.iCurrentItem == 1 && index == KErrNotFound);

	//////////////////////////////////////////////////////////////

	// Test with a list with 2 items, 1-1 range

    // indexes: 01

    // focus:   F

    // order:   01

	TestSingleRange(2, 0, 1, 1, "01ee"); // count, focus, rear, front, result

    // indexes: 01

    // focus:    F

    // order:   10

	TestSingleRange(2, 1, 1, 1, "10ee"); // count, focus, rear, front, result

	//////////////////////////////////////////////////////////////

    // Test with a list with 3 items, 1-1 range

    // indexes: 012

    // focus:   F

    // order:   012

	TestSingleRange(3, 0, 1, 1, "012ee"); // count, focus, rear, front, result

    // indexes: 012

    // focus:    F

    // order:   201

	TestSingleRange(3, 1, 1, 1, "120ee"); // count, focus, rear, front, result

    // indexes: 012

    // focus:     F

    // order:   201

	TestSingleRange(3, 2, 1, 1, "201ee"); // count, focus, rear, front, result

	//////////////////////////////////////////////////////////////

    // Test with a list with 4 items, 1-1 range

    // indexes: 0123

    // focus:   F

    // order:   01 2

	TestSingleRange(4, 0, 1, 1, "013ee"); // count, focus, rear, front, result

    // indexes: 0123

    // focus:    F

    // order:   201 

	TestSingleRange(4, 1, 1, 1, "120ee"); // count, focus, rear, front, result

    // indexes: 0123

    // focus:     F

    // order:    201 

	TestSingleRange(4, 2, 1, 1, "231ee"); // count, focus, rear, front, result

    // indexes: 0123

    // focus:      F

    // order:   1 20

	TestSingleRange(4, 3, 1, 1, "302ee"); // count, focus, rear, front, result

  	}

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

// UT_TestAsymmetricRangeL

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

//

void T_CGlxFromFocusOutwardIterator::UT_TestAsymmetricRangeL(  )

	{

 	// Test with a list with 5 items, 1-2 range

    // indexes: 01234

    // focus:   F

    // order:   013 2

	TestSingleRange(5, 0, 1, 2, "0142ee"); // count, focus, rear, front, result

    // indexes: 01234

    // focus:    F

    // order:   2013 

	TestSingleRange(5, 1, 1, 2, "1203ee"); // count, focus, rear, front, result

    // indexes: 01234

    // focus:     F

    // order:    2013 

	TestSingleRange(5, 2, 1, 2, "2314ee"); // count, focus, rear, front, result

    // indexes: 01234

    // focus:      F

    // order:   3 201

	TestSingleRange(5, 3, 1, 2, "3420ee"); // count, focus, rear, front, result

    // indexes: 01234

    // focus:       F

    // order:   13 20

	TestSingleRange(5, 4, 1, 2, "4031ee"); // count, focus, rear, front, result

	//////////////////////////////////////////////////////////////

	// Test with a list with 5 items, 2-1 range

    // indexes: 01234

    // focus:   F

    // order:   01 32 

	TestSingleRange(5, 0, 2, 1, "0143ee"); // count, focus, rear, front, result

    // indexes: 01234

    // focus:    F

    // order:   201 3 

	TestSingleRange(5, 1, 2, 1, "1204ee"); // count, focus, rear, front, result

    // indexes: 01234

    // focus:     F

    // order:   3201 

	TestSingleRange(5, 2, 2, 1, "2310ee"); // count, focus, rear, front, result

    // indexes: 01234

    // focus:      F

    // order:    3201

	TestSingleRange(5, 3, 2, 1, "3421ee"); // count, focus, rear, front, result

    // indexes: 01234

    // focus:       F

    // order:   1 320

	TestSingleRange(5, 4, 2, 1, "4032ee"); // count, focus, rear, front, result

	//////////////////////////////////////////////////////////////

	// Test with a list with 6 items, 4-2 range

    // indexes: 012345

    // focus:   F

    // order:   013542

	TestSingleRange(6, 0, 4, 2, "015243ee"); // count, focus, rear, front, result

    // indexes: 012345

    // focus:    F

    // order:   201354  

	TestSingleRange(6, 1, 4, 2, "120354ee"); // count, focus, rear, front, result

    // indexes: 012345

    // focus:     F

    // order:   420135 

	TestSingleRange(6, 2, 4, 2, "231405ee"); // count, focus, rear, front, result

    // indexes: 012345

    // focus:      F

    // order:   542013

	TestSingleRange(6, 3, 4, 2, "342510ee"); // count, focus, rear, front, result

    // indexes: 012345

    // focus:       F

    // order:   354201

	TestSingleRange(6, 4, 4, 2, "453021ee"); // count, focus, rear, front, result

    // indexes: 012345

    // focus:        F

    // order:   135420

	TestSingleRange(6, 5, 4, 2, "504132ee"); // count, focus, rear, front, result

	//////////////////////////////////////////////////////////////

	// Test with a list with 7 items, 4-2 range

    // indexes: 0123456

    // focus:   F

    // order:   0136542

	TestSingleRange(7, 0, 4, 2, "0162543ee"); // count, focus, rear, front, result

    // indexes: 0123456

    // focus:    F

    // order:   2013654 

	TestSingleRange(7, 1, 4, 2, "1203654ee"); // count, focus, rear, front, result

    // indexes: 0123456 

    // focus:     F

    // order:   4201365

	TestSingleRange(7, 2, 4, 2, "2314065ee"); // count, focus, rear, front, result

    // indexes: 0123456

    // focus:      F

    // order:   5420136

	TestSingleRange(7, 3, 4, 2, "3425106ee"); // count, focus, rear, front, result

    // indexes: 0123456

    // focus:       F

    // order:   6542013

	TestSingleRange(7, 4, 4, 2, "4536210ee"); // count, focus, rear, front, result

    // indexes: 0123456

    // focus:        F

    // order:   3654201

	TestSingleRange(7, 5, 4, 2, "5640321ee"); // count, focus, rear, front, result

    // indexes: 0123456

    // focus:         F

    // order:   1365420  

	TestSingleRange(7, 6, 4, 2, "6051432ee"); // count, focus, rear, front, result

	//////////////////////////////////////////////////////////////

	// Test with a list with 8 items, 4-2 range

    // indexes: 01234567

    // focus:   F

    // order:   013 6542

	TestSingleRange(8, 0, 4, 2, "0172654ee"); // count, focus, rear, front, result

    // indexes: 01234567

    // focus:    F

    // order:   2013 654 

	TestSingleRange(8, 1, 4, 2, "1203765ee"); // count, focus, rear, front, result

    // indexes: 01234567 

    // focus:     F

    // order:   42013 65

	TestSingleRange(8, 2, 4, 2, "2314076ee"); // count, focus, rear, front, result

    // indexes: 01234567

    // focus:      F

    // order:   542013 6

	TestSingleRange(8, 3, 4, 2, "3425107ee"); // count, focus, rear, front, result

    // indexes: 01234567

    // focus:       F

    // order:   6542013

	TestSingleRange(8, 4, 4, 2, "4536210ee"); // count, focus, rear, front, result

    // indexes: 01234567

    // focus:        F

    // order:    6542013

	TestSingleRange(8, 5, 4, 2, "5647321ee"); // count, focus, rear, front, result

    // indexes: 01234567

    // focus:         F

    // order:   3 654201  

	TestSingleRange(8, 6, 4, 2, "6750432ee"); // count, focus, rear, front, result

    // indexes: 01234567

    // focus:          F

    // order:   13 65420  

	TestSingleRange(8, 7, 4, 2, "7061543ee"); // count, focus, rear, front, result

  	}

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

// UT_TestOneSideRangeL

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

//

void T_CGlxFromFocusOutwardIterator::UT_TestOneSideRangeL(  )

	{

	// 1 item, 1-0 range

	TestSingleRange(1, 0, 1, 0, "0ee"); // count, focus, rear, front, result

	// 1 item, 0-1 range

	TestSingleRange(1, 0, 0, 1, "0ee"); // count, focus, rear, front, result

	//////////////////////////////////////////////////////////////

	// Test with a list with 2 items, 1-0 range

    // indexes: 01

    // focus:   F

    // order:   01

	TestSingleRange(2, 0, 1, 0, "01ee"); // count, focus, rear, front, result

    // indexes: 01

    // focus:    F

    // order:   01

	TestSingleRange(2, 1, 1, 0, "10ee"); // count, focus, rear, front, result

	//////////////////////////////////////////////////////////////

	// Test with a list with 2 items, 0-1 range

    // indexes: 01

    // focus:   F

    // order:   01

	TestSingleRange(2, 0, 0, 1, "01ee"); // count, focus, rear, front, result

    // indexes: 01

    // focus:    F

    // order:   01

	TestSingleRange(2, 1, 0, 1, "10ee"); // count, focus, rear, front, result

	//////////////////////////////////////////////////////////////

    // Test with a list with 3 items, 0-1 range

    // indexes: 012

    // focus:   F

    // order:   01

	TestSingleRange(3, 0, 0, 1, "01ee"); // count, focus, rear, front, result

    // indexes: 012

    // focus:    F

    // order:    01

	TestSingleRange(3, 1, 0, 1, "12ee"); // count, focus, rear, front, result

    // indexes: 012

    // focus:     F

    // order:   1 0

	TestSingleRange(3, 2, 0, 1, "20ee"); // count, focus, rear, front, result

	//////////////////////////////////////////////////////////////

    // Test with a list with 3 items, 1-0 range

    // indexes: 012

    // focus:   F

    // order:   0 1

	TestSingleRange(3, 0, 1, 0, "02ee"); // count, focus, rear, front, result

    // indexes: 012

    // focus:    F

    // order:   10

	TestSingleRange(3, 1, 1, 0, "10ee"); // count, focus, rear, front, result

    // indexes: 012

    // focus:     F

    // order:    10

	TestSingleRange(3, 2, 1, 0, "21ee"); // count, focus, rear, front, result

	//////////////////////////////////////////////////////////////

    // Test with a list with 3 items, 0-2 range

    // indexes: 012

    // focus:   F

    // order:   012

	TestSingleRange(3, 0, 0, 2, "012ee"); // count, focus, rear, front, result

    // indexes: 012

    // focus:    F

    // order:   201

	TestSingleRange(3, 1, 0, 2, "120ee"); // count, focus, rear, front, result

    // indexes: 012

    // focus:     F

    // order:   120

	TestSingleRange(3, 2, 0, 2, "201ee"); // count, focus, rear, front, result

	//////////////////////////////////////////////////////////////

    // Test with a list with 3 items, 2-0 range

    // indexes: 012

    // focus:   F

    // order:   021

	TestSingleRange(3, 0, 2, 0, "021ee"); // count, focus, rear, front, result

    // indexes: 012

    // focus:    F

    // order:   102

	TestSingleRange(3, 1, 2, 0, "102ee"); // count, focus, rear, front, result

    // indexes: 012

    // focus:     F

    // order:   210

	TestSingleRange(3, 2, 2, 0, "210ee"); // count, focus, rear, front, result

	//////////////////////////////////////////////////////////////

    // Test with a list with 2 items, 0-2 range

    // indexes: 01

    // focus:   F

    // order:   01

	TestSingleRange(2, 0, 0, 2, "01ee"); // count, focus, rear, front, result

    // indexes: 01

    // focus:    F

    // order:   10

	TestSingleRange(2, 1, 0, 2, "10ee"); // count, focus, rear, front, result

	//////////////////////////////////////////////////////////////

    // Test with a list with 3 items, 2-0 range

    // indexes: 01

    // focus:   F

    // order:   01

	TestSingleRange(2, 0, 2, 0, "01ee"); // count, focus, rear, front, result

    // indexes: 01

    // focus:    F

    // order:   10

	TestSingleRange(2, 1, 2, 0, "10ee"); // count, focus, rear, front, result

  	}

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

// Run a single test

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

//

void T_CGlxFromFocusOutwardIterator::TestSingleRange(TInt aCount, 

		TInt aFocusIndex, TInt aRearOffset, TInt aFrontOffset, char* aResults)

	{

    __ASSERT_DEBUG(aFocusIndex >= 0 && aFocusIndex < aCount && aCount >= 0, Panic(EGlxPanicIllegalArgument)); // Make sure is testing all cases, also failed case

	// Test with a list with 5 items, 1-2 range

    iFocusOrder.SetRangeOffsets(aRearOffset, aFrontOffset);

    iOrder->SetToFirst(&iList); 

    iList.iCount = aCount; 

    iList.iFocusIndex = aFocusIndex;

    // poor man's strlen...

    TInt resultCount = 0;

    char* tmp = aResults;

    while (*tmp) 

    	{

    	resultCount++;

    	tmp++;

    	}

    __ASSERT_DEBUG(resultCount > aFrontOffset + aRearOffset + 1, Panic(EGlxPanicIllegalArgument)); // Make sure is testing all cases, also failed case

    for (TInt i = 0; i < resultCount; i++)

    	{

    	TInt result = (*iOrder)++;

    	char c = aResults[i];

    	TInt expectedResult = c - '0';

    	if (c == 'e') 

    		{

    		expectedResult = KErrNotFound;

    		}

    	EUNIT_ASSERT(result == expectedResult);

    	}

	}

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

// Run a single in range test