// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// which accompanies this distribution, and is available

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32test\buffer\t_que.cpp

// Overview:

// Test double linked list functionality.

// API Information:

// TDblQueLinkBase, TDeltaQueLink, TDblQueLink, TPriQueLink,

// TDblQueIterBase, TDblQueIter

// Details:

// - Create many TDblQueLinkBase links, insert links at specified locations

// and check previous and next links are as expected.

// - Create many TDeltaQueLink links, insert these links at specified locations

// and check previous and next links are as expected.

// - Create many TDblQueLink links, insert, remove these links at specified

// locations and check previous and next links are as expected.

// - Create many TPriQueLink links, insert, remove these links at specified

// locations and check previous and next links are as expected.

// - Create TDblQueBase based object without offset, with specified offset 

// and check it is constructed as expected.

// - Create TDblQueBase based object, insert and remove TPriQueLink list 

// element, set priorities of TPriQueLink list elements, call IsEmpty 

// and Reset methods.

// - Create TDblQueBase based object without, with offset and check 

// it is constructed as expected

// - Create TDblQueBase based object, insert TDblQueLink links at 

// specified locations and check that they are added as expected.

// - Initialise TPriQueLink link with different priorities, insert 

// the elements in priority order and check that they are added 

// as expected.

// - Create TDblQueBase based object, check the double linked list for empty

// before inserting, after inserting, before/after Deque, before/after Enque,

// after Reset. Verify that results are as expected.

// - Create TDeltaQueBase object without offset, with specified offset

// and check it is constructed as expected. Insert TDeltaQueLink list 

// elements at specified distance from the zero point, remove the elements 

// at specified distance, decrement the delta value.

// - Create TDeltaQueBase based object, insert TDblQueLink link at specified 

// locations and check the previous, next link are as expected.

// - Check the linked list for empty before inserting, after inserting, 

// before/after Deque, before/after Enque, after Reset. Verify that results 

// are as expected.

// - Create TDeltaQueBase based object, insert links using DoAddDelta method,

// check that links are as expected. Delete links using DoRemove and 

// DoRemoveFirst methods and check that links are as expected.

// - Create TDeltaQueBase based object, insert links using DoAddDelta method,

// check the return value of CountDown is as expected. Delete links using 

// DoRemoveFirst method and check the return value of CountDown is as expected.

// - Create TDblQue based object, insert links at front and last, call IsHead, 

// IsFirst, IsLast, First and Last methods.

// - Create TDblQue object, check list for empty before inserting, after 

// inserting, before/after Deque, before/after Enque, after Reset. 

// Verify that results are as expected.

// - Create TDblQue based object with offset constructor, insert links at

// specified locations and check it is added as specified.

// - Create TDblQue based object, insert links using AddFirst and AddLast and

// check the links are as expected.

// - Create TDblQue based object, insert links using AddFirst and AddLast and

// check the result of the IsHead, IsFirst and IsLast methods are as expected.

// - Create TDblQue based object, insert links using AddFirst and AddLast, check 

// the results are as expected.

// - Create TPriQueLink list without offset, with different offset, check the 

// construction is as expected.

// - Create TPriQueLink list and insert many links at different specified location

// and check it is added as specified.

// - Create TPriQueLink link with different priorities, insert the elements in 

// priority order and check that they are added as expected.

// - Create TPriQueLink list, check the double linked list for empty before 

// inserting, after inserting, before/after Deque, before/after Enque, after Reset. 

// Verify that results are as expected.

// - Create TPriQueLink list with different offset, get the list offset and check it

// is as expected.

// - Create TPriQueLink list, insert many links with different priorities check it is 

// as expected.

// - Create TDeltaQueLink list, add ,remove links and check the links and check 

// it is as expected.

// - Create TDeltaQueLink list and insert many links at different specified location

// and check it is added as specified.

// - Create TDeltaQueLink list, check the double linked list for empty before, after 

// inserting, before Deque, after Enque, Reset method call is as expected.

// - Create TDeltaQueLink list, insert links using DoAddDelta method,check that 

// links are as expected. Delete links using DoRemove and DoRemoveFirst methods

// and check that links are as expected.

// - Create TDeltaQueLink based object, insert links using DoAddDelta method,

// check the return value of CountDown is as expected. Delete links using 

// DoRemoveFirst method and check the return value of CountDown is as expected.

// - Create TDeltaQueLink list with different offset, get and check the offset is 

// as expected.

// - Create TDeltaQueLink list, add, remove links at different specified location 

// and check it is added and removed successfully.

// - Initialaize TDblQueIterBase based iterator, get the current item in the queue, 

// move the current position forward, backward, set the iterator to point to the 

// first element, last item and check it is as expected.

// - Create TDblQueIterBase object with offset constructor, insert links at

// specified locations and check it is added as specified.

// - Create TDblQueIterBase object, iterate the list using operators, DoPostInc, 

// DoPostDec, DoCurrent and check it is as expected.

// - Create TDblQue based link with specified offset, initialize TDblQueIter 

// based iterator, iterate the link and check the offset is as expected.

// - Create TDblQueIter object with offset constructor, insert links at

// specified locations and check it is added as specified.

// - Create TDblQueIter object, iterate the list using operators, DoPostInc, 

// DoPostDec, DoCurrent and check it is as expected.

// - Create TDblQueIter based object, insert links using AddFirst and SetToLast,

// using IsHead, check the results are as expected.

// Platforms/Drives/Compatibility:

// All 

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

LOCAL_D RTest test(_L("T_QUE"));

#ifndef _DEBUG

#pragma warning(disable : 4710) //fuction not expanded

#endif

#define SIZE 10

#define MAX_OFFSET 10

struct Item

	{

	TDblQueLink iLink;

	TInt iSpace[MAX_OFFSET]; // Reserve some space

	};

class CItem : public CBase

	{

public:

	TDblQueLink iLink;

	//int iSpac[MAX_OFFSET]; // Reserve some space

	};

template<class T>

class TestTQueLink

	{

public:

	void TestQueLinkBase();	// Calls Test: 1.

	void TestQueLink();	// Calls Test: 1,2.

	void Test1();	// Test Enque

	void Test2();	// Test Deque

protected:

	void CreateObjects(TInt aBaseLink);

	void DestroyObjects();

private:

	void CallTest1();

	T* iLink[SIZE];

	};

template<class T>

void TestTQueLink<T>::CallTest1()

	{

	test.Start(_L("Test Enque"));

	Test1();

	}

template<class T>

void TestTQueLink<T>::CreateObjects(TInt aBaseLink)

	{

	TInt i;

	for (i=0;i<SIZE;i++)

		iLink[i]=new T;

	if (aBaseLink>=0&&aBaseLink<SIZE)

		(iLink[aBaseLink])->iNext=(iLink[aBaseLink])->iPrev=iLink[aBaseLink];

	}

template<class T>

void TestTQueLink<T>::DestroyObjects()

	{

	TInt i;

	for (i=0;i<SIZE;i++)

		delete iLink[i];

	}

template<class T>

void TestTQueLink<T>::TestQueLinkBase()

	{

	CallTest1();

	test.Next(_L("Finished"));

	test.End();

	}

template <class T>

void TestTQueLink<T>::TestQueLink()

	{

	CallTest1();

	test.Next(_L("Text Deque"));

	Test2();

	test.Next(_L("Finished"));

	test.End();

	}

template<class T>

void TestTQueLink<T>::Test1()

	{

	CreateObjects(1);

	test.Start(_L("Check Next and Prev pointers set corectly."));

	iLink[2]->Enque(iLink[1]);

	test(iLink[1]->iPrev==iLink[2]);

	test(iLink[1]->iNext==iLink[2]);

	test(iLink[2]->iPrev==iLink[1]);

	test(iLink[2]->iNext==iLink[1]);

	iLink[3]->Enque(iLink[2]);

	test(iLink[1]->iPrev==iLink[3]);

	test(iLink[1]->iNext==iLink[2]);

	test(iLink[2]->iPrev==iLink[1]);

	test(iLink[2]->iNext==iLink[3]);

	test(iLink[3]->iPrev==iLink[2]);

	test(iLink[3]->iNext==iLink[1]);

	iLink[4]->Enque(iLink[3]);

	test(iLink[1]->iPrev==iLink[4]);

	test(iLink[1]->iNext==iLink[2]);

	test(iLink[2]->iPrev==iLink[1]);

	test(iLink[2]->iNext==iLink[3]);

	test(iLink[3]->iPrev==iLink[2]);

	test(iLink[3]->iNext==iLink[4]);

	test(iLink[4]->iPrev==iLink[3]);

	test(iLink[4]->iNext==iLink[1]);

	iLink[5]->Enque(iLink[2]);

	test(iLink[1]->iPrev==iLink[4]);

	test(iLink[1]->iNext==iLink[2]);

	test(iLink[2]->iPrev==iLink[1]);

	test(iLink[2]->iNext==iLink[5]);

	test(iLink[5]->iPrev==iLink[2]);

	test(iLink[5]->iNext==iLink[3]);

	test(iLink[3]->iPrev==iLink[5]);

	test(iLink[3]->iNext==iLink[4]);

	test(iLink[4]->iPrev==iLink[3]);

	test(iLink[4]->iNext==iLink[1]);

	test.Next(_L("Finished"));

	DestroyObjects();

	test.End();

	}

template<class T>

void TestTQueLink<T>::Test2()

	{

	CreateObjects(1);

	test.Start(_L("Check Next and Prev pointers set corectly"));

	iLink[2]->Enque(iLink[1]);

	iLink[3]->Enque(iLink[2]);

	iLink[4]->Enque(iLink[3]);

	iLink[5]->Enque(iLink[4]);

	iLink[5]->Deque();

	iLink[5]->Enque(iLink[2]);

	test(iLink[1]->iPrev==iLink[4]);

	test(iLink[1]->iNext==iLink[2]);

	test(iLink[2]->iPrev==iLink[1]);

	test(iLink[2]->iNext==iLink[5]);

	test(iLink[5]->iPrev==iLink[2]);

	test(iLink[5]->iNext==iLink[3]);

	test(iLink[3]->iPrev==iLink[5]);

	test(iLink[3]->iNext==iLink[4]);

	test(iLink[4]->iPrev==iLink[3]);

	test(iLink[4]->iNext==iLink[1]);

	iLink[3]->Deque();

	test(iLink[1]->iPrev==iLink[4]);

	test(iLink[1]->iNext==iLink[2]);

	test(iLink[2]->iPrev==iLink[1]);

	test(iLink[2]->iNext==iLink[5]);

	test(iLink[5]->iPrev==iLink[2]);

	test(iLink[5]->iNext==iLink[4]);

	test(iLink[4]->iPrev==iLink[5]);

	test(iLink[4]->iNext==iLink[1]);

	iLink[1]->Deque();

	test(iLink[2]->iPrev==iLink[4]);

	test(iLink[2]->iNext==iLink[5]);

	test(iLink[5]->iPrev==iLink[2]);

	test(iLink[5]->iNext==iLink[4]);

	test(iLink[4]->iPrev==iLink[5]);

	test(iLink[4]->iNext==iLink[2]);

	iLink[4]->Deque();

	test(iLink[2]->iPrev==iLink[5]);

	test(iLink[2]->iNext==iLink[5]);

	test(iLink[5]->iPrev==iLink[2]);

	test(iLink[5]->iNext==iLink[2]);

	test.Next(_L("Finished"));

	DestroyObjects();

	test.End();

	}

class VDblQueBase : public TDblQueBase

	{

public:

	VDblQueBase();

	VDblQueBase(TInt anOffset);

	inline void sDoAddFirst(TAny* aPtr) {DoAddFirst(aPtr);}

	inline void sDoAddLast(TAny* aPtr) {DoAddLast(aPtr);}

	inline void sDoAddPriority(TAny* aPtr) {DoAddPriority(aPtr);}

	inline void sTestEmpty() const {__DbgTestEmpty();}

	TDblQueLink* sHead;

	TInt* sOffset;

private:

	void SetMembers();

	};

class VDeltaQueBase : public TDeltaQueBase

	{

public:

	VDeltaQueBase();

	VDeltaQueBase(TInt anOffset);

	inline void sDoAddDelta(TAny* aPtr,TInt aDelta) {DoAddDelta(aPtr,aDelta);}		//From TDeltaQueBase

	inline void sDoRemove(TAny* aPtr) {this->DoRemove(aPtr);}

	inline TAny* sDoRemoveFirst() {return this->DoRemoveFirst();}

	TInt** sFirstDelta;

	inline void sDoAddFirst(TAny* aPtr) {DoAddFirst(aPtr);}		//From TDblQueBase

	inline void sDoAddLast(TAny* aPtr) {DoAddLast(aPtr);}

	inline void sDoAddPriority(TAny* aPtr) {DoAddPriority(aPtr);}

	TDblQueLink* sHead;

	TInt* sOffset;

private:

	void SetMembers();

	};

template <class T>

class VDblQue : public TDblQue<T>

	{

public:

	VDblQue();

	VDblQue(TInt anOffset);

	/*inline void sDoAddDelta(TAny* aPtr,TInt aDelta) {DoAddDelta(aPtr,aDelta);}		//From TDeltaQueBase

	inline void sDoRemove(TAny* aPtr) {this->DoRemove(aPtr);}

	inline TAny* sDoRemoveFirst() {return this->DoRemoveFirst();}

	TInt** sFirstDelta;*/

	inline void sDoAddFirst(TAny* aPtr) {this->DoAddFirst(aPtr);}		//From TDblQueBase

	inline void sDoAddLast(TAny* aPtr) {this->DoAddLast(aPtr);}

	inline void sDoAddPriority(TAny* aPtr) {this->DoAddPriority(aPtr);}

	TDblQueLink* sHead;

	TInt* sOffset;

private:

	void SetMembers();

	};

template <class T>

class VPriQue : public TPriQue<T>

	{

public:

	VPriQue();

	VPriQue(TInt anOffset);

	/*inline void sDoAddDelta(TAny* aPtr,TInt aDelta) {DoAddDelta(aPtr,aDelta);}		//From TDeltaQueBase

	inline void sDoRemove(TAny* aPtr) {this->DoRemove(aPtr);}

	inline TAny* sDoRemoveFirst() {return this->DoRemoveFirst();}

	TInt** sFirstDelta;*/

	inline void sDoAddFirst(TAny* aPtr) {this->DoAddFirst(aPtr);}		//From TDblQueBase

	inline void sDoAddLast(TAny* aPtr) {this->DoAddLast(aPtr);}

	inline void sDoAddPriority(TAny* aPtr) {this->DoAddPriority(aPtr);}

	TDblQueLink* sHead;

	TInt* sOffset;

private:

	void SetMembers();

	};

template <class T>

class VDeltaQue : public TDeltaQue<T>

	{

public:

	VDeltaQue();

	VDeltaQue(TInt anOffset);

	inline void sDoAddDelta(TAny* aPtr,TInt aDelta) {this->DoAddDelta(aPtr,aDelta);}		//From TDeltaQueBase

	inline void sDoRemove(TAny* aPtr) {this->DoRemove(aPtr);}

	inline TAny* sDoRemoveFirst() {return this->DoRemoveFirst();}

	TInt** sFirstDelta;

	inline void sDoAddFirst(TAny* aPtr) {this->DoAddFirst(aPtr);}		//From TDblQueBase

	inline void sDoAddLast(TAny* aPtr) {this->DoAddLast(aPtr);}

	inline void sDoAddPriority(TAny* aPtr) {this->DoAddPriority(aPtr);}

	TDblQueLink* sHead;

	TInt* sOffset;

private:

	void SetMembers();

	};

VDblQueBase::VDblQueBase()

	{

	SetMembers();

	}

VDblQueBase::VDblQueBase(TInt anOffset)

	:TDblQueBase(anOffset)

	{

	SetMembers();

	}

void VDblQueBase::SetMembers()

	{

	sHead=&iHead;

	sOffset=&iOffset;

	}

VDeltaQueBase::VDeltaQueBase()

	{

	SetMembers();

	}

VDeltaQueBase::VDeltaQueBase(TInt anOffset)

	:TDeltaQueBase(anOffset)

	{

	SetMembers();

	}

void VDeltaQueBase::SetMembers()

	{

	sFirstDelta=&iFirstDelta;

	sHead=&iHead;

	sOffset=&iOffset;

	}

template <class T>

VDblQue<T>::VDblQue()

	{

	SetMembers();

	}

template <class T>

VDblQue<T>::VDblQue(TInt anOffset)

	:TDblQue<T>(anOffset)

	{

	SetMembers();

	}

template <class T>

void VDblQue<T>::SetMembers()

	{

	//sFirstDelta=&iFirstDelta;

	sHead=&this->iHead;

	sOffset=&this->iOffset;

	}

template <class T>

VPriQue<T>::VPriQue()

	{

	SetMembers();

	}

template <class T>

VPriQue<T>::VPriQue(TInt anOffset)

	:TPriQue<T>(anOffset)

	{

	SetMembers();

	}

template <class T>

void VPriQue<T>::SetMembers()

	{

	//sFirstDelta=&iFirstDelta;

	sHead=&this->iHead;

	sOffset=&this->iOffset;

	}

template <class T>

VDeltaQue<T>::VDeltaQue()

	{

	SetMembers();

	}

template <class T>

VDeltaQue<T>::VDeltaQue(TInt anOffset)

	:TDeltaQue<T>(anOffset)

	{

	SetMembers();

	}

template <class T>

void VDeltaQue<T>::SetMembers()

	{

	sFirstDelta=&this->iFirstDelta;

	sHead=&this->iHead;

	sOffset=&this->iOffset;

	}

template<class T>

class TestTQue

	{

friend class TestTQueLink<TDblQueLinkBase>;

public:

	void TestQueBase();

	void TestDeltaBase();

	void TestDblQue();

	void TestPriQue();

	void TestDeltaQue();

	void Test1();	// All functions		//TDblQueBase functions

	void Test2();	// Constructors

	void Test3(TBool aTestPri);	// DoAdd's

	void Test4();	// Public functions

	void Test5();	// All functions		//TDblDeltaQueBase

	void Test6();	// Constructors

	void Test7();	// Do's

	void Test8();	// CountDown

	void Test9();	// All functions		//TDblQueBase

	void Test10();	// Constructors

	void Test11();	// Add's

	void Test12();	// Is's

	void Test13();	// Get's

	void Test14();	// All functions		//TPriQue

	void Test15();	// Constructors

	void Test16();	// Add

	void Test17();	// All functions		//TDeltaQue

	void Test18();	// Constructors

	void Test19();	// Add/Remove

private:

	void CallTest3_4(TBool aTestPri);	

	void CallTest7_8();	

	};

template<class T>

void TestTQue<T>::CallTest3_4(TBool aTestPri)

	{

	test.Next(_L("Test DoAdd's"));

	Test3(aTestPri);

	test.Next(_L("Test public functions"));

	Test4();

	}