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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// 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();

	}

template<class T>

void TestTQue<T>::CallTest7_8()

	{

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

	Test7();

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

	Test8();

	}

template<class T>

void TestTQue<T>::TestQueBase()

	{

	test.Start(_L("Test all member functions (simply)"));

	Test1();

	test.Next(_L("Test Constructors"));

	Test2();

	CallTest3_4(ETrue);

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

	test.End();

	}

template<class T>

void TestTQue<T>::TestDeltaBase()

	{

	test.Start(_L("Test all member functions (simply)"));

	Test5();

	CallTest3_4(EFalse);

	test.Next(_L("Test Constructors"));

	Test6();

	CallTest7_8();

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

	test.End();

	}

template<class T>

void TestTQue<T>::TestDblQue()

	{

	test.Start(_L("Test all member functions (simply)"));

	Test9();

	CallTest3_4(EFalse);

	test.Next(_L("Test Constructor"));

	Test10();

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

	Test11();

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

	Test12();

	test.Next(_L("Get's"));

	Test13();

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

	test.End();

	}

template<class T>

void TestTQue<T>::TestPriQue()

	{

	test.Start(_L("Test all member functions (simply)"));

	Test14();

	CallTest3_4(ETrue);

	test.Next(_L("Test Constructor"));

	Test15();

	test.Next(_L("Test Add"));

	Test16();

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

	test.End();

	}

template<class T>

void TestTQue<T>::TestDeltaQue()

	{

	test.Start(_L("Test all member functions (simply)"));

	Test17();

	CallTest3_4(EFalse);

	CallTest7_8();

	test.Next(_L("Test Constructor"));

	Test18();

	test.Next(_L("Test Add/Removes"));

	Test19();

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

	test.End();

	}

template<class T>

void TestTQue<T>::Test1()

	{

	T* que;

	TPriQueLink link1,link2;

	TInt offset=4;

	test.Start(_L("Constructors"));

	que=new VDblQueBase(offset);

	delete que;

	que=new VDblQueBase;

	//delete que;

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

	que->sDoAddFirst(&link1);

	link1.Deque();

	que->sDoAddLast(&link1);

	link1.iPriority=1;

	link2.iPriority=2;

	que->sDoAddPriority(&link2);

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

	que->IsEmpty();

	que->SetOffset(offset);

	que->Reset();

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

	delete que;

	test.End();

	}

template<class T>

void TestTQue<T>::Test2()

	{

	T* que;

	TInt offset;

	test.Start(_L("Default constructor"));

	que=new VDblQueBase();

	test(*(que->sOffset)==0);

	test(que->sHead->iNext==que->sHead);

	test(que->sHead->iPrev==que->sHead);

	delete que;

	test.Next(_L("Offset constructor"));

	for (offset=0;offset<40;offset+=4)

		{

		que=new VDblQueBase(offset);

		test(*(que->sOffset)==offset);

		test(que->sHead->iNext==que->sHead);

		test(que->sHead->iPrev==que->sHead);

		delete que;

		}

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

	test.End();

	}

template<class T>

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

	{

	T* que;

	TDblQueLink link1,link2,link3,link4;

	test.Start(_L("AddFirst"));

	que=new T();

	que->sDoAddFirst(&link1);

	test(que->sHead->iNext==&link1);

	test(que->sHead->iPrev==&link1);

	test(link1.iNext==que->sHead);

	test(link1.iPrev==que->sHead);

 	que->sDoAddFirst(&link2);

	test(que->sHead->iNext==&link2);

	test(que->sHead->iPrev==&link1);

	test(link1.iNext==que->sHead);

	test(link1.iPrev==&link2);

	test(link2.iNext==&link1);

	test(link2.iPrev==que->sHead);

  	que->sDoAddFirst(&link3);

	test(que->sHead->iNext==&link3);

	test(que->sHead->iPrev==&link1);

	test(link1.iNext==que->sHead);

	test(link1.iPrev==&link2);

	test(link2.iNext==&link1);

	test(link2.iPrev==&link3);

	test(link3.iNext==&link2);

	test(link3.iPrev==que->sHead);

  	que->sDoAddFirst(&link4);

	test(que->sHead->iNext==&link4);

	test(que->sHead->iPrev==&link1);

	test(link1.iNext==que->sHead);

	test(link1.iPrev==&link2);

	test(link2.iNext==&link1);

	test(link2.iPrev==&link3);

	test(link3.iNext==&link2);

	test(link3.iPrev==&link4);

	test(link4.iNext==&link3);

	test(link4.iPrev==que->sHead);

	link1.Deque();

	link2.Deque();

	link3.Deque();

	link4.Deque();

	delete que;

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

	que=new T();

	que->sDoAddLast(&link1);

	test(que->sHead->iNext==&link1);

	test(que->sHead->iPrev==&link1);

	test(link1.iNext==que->sHead);

	test(link1.iPrev==que->sHead);

	que->sDoAddLast(&link2);

	test(que->sHead->iNext==&link1);

	test(que->sHead->iPrev==&link2);

	test(link1.iNext==&link2);

	test(link1.iPrev==que->sHead);

	test(link2.iNext==que->sHead);

	test(link2.iPrev==&link1);

	que->sDoAddLast(&link3);

	test(que->sHead->iNext==&link1);

	test(que->sHead->iPrev==&link3);

	test(link1.iNext==&link2);

	test(link1.iPrev==que->sHead);

	test(link2.iNext==&link3);

	test(link2.iPrev==&link1);

	test(link3.iNext==que->sHead);

	test(link3.iPrev==&link2);

	que->sDoAddLast(&link4);

	test(que->sHead->iNext==&link1);

	test(que->sHead->iPrev==&link4);

	test(link1.iNext==&link2);

	test(link1.iPrev==que->sHead);

	test(link2.iNext==&link3);

	test(link2.iPrev==&link1);

	test(link3.iNext==&link4);

	test(link3.iPrev==&link2);

	test(link4.iNext==que->sHead);

	test(link4.iPrev==&link3);

	link1.Deque();

	link2.Deque();

	link3.Deque();

	link4.Deque();

 	delete que;

	test.Next(_L("Combined AddFirst and AddLast"));

 	que=new T();

	que->sDoAddFirst(&link1);

	que->sDoAddLast(&link2);

 	test(que->sHead->iNext==&link1);

	test(que->sHead->iPrev==&link2);

	test(link1.iNext==&link2);

	test(link1.iPrev==que->sHead);

	test(link2.iNext==que->sHead);

	test(link2.iPrev==&link1);

	que->sDoAddFirst(&link3);

 	test(que->sHead->iNext==&link3);

	test(que->sHead->iPrev==&link2);

	test(link1.iNext==&link2);

	test(link1.iPrev==&link3);

	test(link2.iNext==que->sHead);

	test(link2.iPrev==&link1);

	test(link3.iNext==&link1);

	test(link3.iPrev==que->sHead);

	que->sDoAddLast(&link4);

  	test(que->sHead->iNext==&link3);

	test(que->sHead->iPrev==&link4);

	test(link1.iNext==&link2);

	test(link1.iPrev==&link3);

	test(link2.iNext==&link4);

	test(link2.iPrev==&link1);

	test(link3.iNext==&link1);

	test(link3.iPrev==que->sHead);

	test(link4.iNext==que->sHead);

	test(link4.iPrev==&link2);

	link1.Deque();

	link2.Deque();

	link3.Deque();

	link4.Deque();

 	delete que;

	if (aTestPri)

	{

		TPriQueLink link5,link6,link7,link8,link9,link10;

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

	 	que=new T();

		link5.iPriority=4;

		link6.iPriority=6;

		link7.iPriority=8;

		que->sDoAddPriority(&link5);

		que->sDoAddPriority(&link6);

		que->sDoAddPriority(&link7);

  		test(que->sHead->iNext==&link7);

		test(que->sHead->iPrev==&link5);

		test(link5.iNext==que->sHead);

		test(link5.iPrev==&link6);

		test(link6.iNext==&link5);

		test(link6.iPrev==&link7);

		test(link7.iNext==&link6);

		test(link7.iPrev==que->sHead);

		link8.iPriority=7;

		que->sDoAddPriority(&link8);

  		test(que->sHead->iNext==&link7);

		test(que->sHead->iPrev==&link5);

		test(link5.iNext==que->sHead);

		test(link5.iPrev==&link6);

		test(link6.iNext==&link5);

		test(link6.iPrev==&link8);

		test(link7.iNext==&link8);

		test(link7.iPrev==que->sHead);

		test(link8.iPrev==&link7);

		test(link8.iNext==&link6);

		link9.iPriority=5;

		que->sDoAddPriority(&link9);

  		test(que->sHead->iNext==&link7);

		test(que->sHead->iPrev==&link5);

		test(link5.iNext==que->sHead);

		test(link5.iPrev==&link9);

		test(link6.iNext==&link9);

		test(link6.iPrev==&link8);

		test(link7.iNext==&link8);

		test(link7.iPrev==que->sHead);

		test(link8.iPrev==&link7);

		test(link8.iNext==&link6);

		test(link9.iPrev==&link6);

		test(link9.iNext==&link5);

		link10.iPriority=3;

		que->sDoAddPriority(&link10);

  		test(que->sHead->iNext==&link7);

		test(que->sHead->iPrev==&link10);

		test(link5.iNext==&link10);

		test(link5.iPrev==&link9);

		test(link6.iNext==&link9);

		test(link6.iPrev==&link8);

		test(link7.iNext==&link8);

		test(link7.iPrev==que->sHead);

		test(link8.iPrev==&link7);

		test(link8.iNext==&link6);

		test(link9.iPrev==&link6);

		test(link9.iNext==&link5);

 		test(link10.iNext==que->sHead);

		test(link10.iPrev==&link5);

		link5.Deque();

		link6.Deque();

		link7.Deque();

		link8.Deque();

	 	delete que;

		}

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

	test.End();

	}

template<class T>

void TestTQue<T>::Test4()

	{

	T* que;

	TInt offset;

	test.Start(_L("IsEmpty"));

	que=new T();

	test(que->IsEmpty()==TRUE);

	TDblQueLink link1,link2;

	que->sDoAddFirst(&link1);

	test(que->IsEmpty()==FALSE);

	link1.Deque();

	test(que->IsEmpty()==TRUE);

	que->sDoAddLast(&link2);

	test(que->IsEmpty()==FALSE);

	link1.Enque(&link2);

	test(que->IsEmpty()==FALSE);

	link2.Deque();

	test(que->IsEmpty()==FALSE);

 	link1.Deque();

	test(que->IsEmpty()==TRUE);

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

	que->sDoAddFirst(&link1);

	test(que->IsEmpty()==FALSE);

	que->Reset();

	test(que->IsEmpty()==TRUE);

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

	for (offset=0;offset<40;offset+=4)

		{

		que->SetOffset(offset);

		test(*(que->sOffset)==offset);

		}

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

 	delete que;

	test.End();

	}

template<class T>

void TestTQue<T>::Test5()

	{

	T* que;

	TDeltaQueLink link1,link2,link3;

	TInt offset=4;

	test.Start(_L("Constructors"));

	que=new VDeltaQueBase(offset);

	delete que;

	que=new VDeltaQueBase;

	test.Next(_L("Do's"));

	que->sDoAddDelta(&link1,3);

	que->sDoAddDelta(&link2,2);

	que->sDoAddDelta(&link3,0);

	que->sDoRemoveFirst();

	que->sDoRemove(&link2);

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

	que->CountDown();

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

	delete que;

	test.End();

	}

template<class T>

void TestTQue<T>::Test6()

	{

	T* que;

	TInt offset;

	test.Start(_L("Default constructor"));

	que=new VDeltaQueBase();

	test(*(que->sFirstDelta)==NULL);

	delete que;

	test.Next(_L("Offset constructor"));

	for (offset=0;offset<40;offset+=4)

		{

		que=new VDeltaQueBase(offset);

		test(*(que->sOffset)==offset);

		test(*(que->sFirstDelta)==NULL);

		delete que;

		}

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

	test.End();

	}

template<class T>

void TestTQue<T>::Test7()

	{

	T* que;

	TDeltaQueLink link1,link2,link3,link4,link5,link6;

	test.Start(_L("DoAddDelta"));

	que=new T();

	que->sDoAddDelta(&link2,3);

	test(*(que->sFirstDelta)==&link2.iDelta);

	test(link2.iDelta==3);

	que->sDoAddDelta(&link5,15);

	test(*(que->sFirstDelta)==&link2.iDelta);

	test(link2.iDelta==3);

	test(link5.iDelta==12);

	que->sDoAddDelta(&link3,6);

	test(*(que->sFirstDelta)==&link2.iDelta);

	test(link2.iDelta==3);

	test(link3.iDelta==3);

	test(link5.iDelta==9);

	que->sDoAddDelta(&link4,10);

	test(*(que->sFirstDelta)==&link2.iDelta);

	test(link2.iDelta==3);

	test(link3.iDelta==3);

	test(link4.iDelta==4);

	test(link5.iDelta==5);

	que->sDoAddDelta(&link1,1);

	test(*(que->sFirstDelta)==&link1.iDelta);

	test(link1.iDelta==1);

	test(link2.iDelta==2);

	test(link3.iDelta==3);

	test(link4.iDelta==4);

	test(link5.iDelta==5);

	que->sDoAddDelta(&link6,21);

	test(*(que->sFirstDelta)==&link1.iDelta);

	test(link1.iDelta==1);

	test(link2.iDelta==2);

	test(link3.iDelta==3);

	test(link4.iDelta==4);

	test(link5.iDelta==5);

	test(link6.iDelta==6);

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

	que->sDoRemove(&link6);

	test(*(que->sFirstDelta)==&link1.iDelta);

	test(link1.iDelta==1);

	test(link2.iDelta==2);

	test(link3.iDelta==3);

	test(link4.iDelta==4);

	test(link5.iDelta==5);

 	que->sDoRemove(&link1);

	test(*(que->sFirstDelta)==&link2.iDelta);

	test(link2.iDelta==3);

	test(link3.iDelta==3);

	test(link4.iDelta==4);

	test(link5.iDelta==5);

	que->sDoRemove(&link4);

	test(*(que->sFirstDelta)==&link2.iDelta);