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

 	test(link2.iDelta==3);

 	test(link3.iDelta==3);

 	test(link5.iDelta==9);

 	que->sDoRemove(&link3);

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

 	test(link2.iDelta==3);

 	test(link5.iDelta==12);

 	que->sDoRemove(&link5);

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

 	test(link2.iDelta==3);

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

 	test(NULL==que->sDoRemoveFirst());

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

 	test(link2.iDelta==3);

 	link2.iDelta=1;

 	test(NULL==que->sDoRemoveFirst());

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

 	test(link2.iDelta==1);

 	link2.iDelta=0;

 	test(&link2==que->sDoRemoveFirst());

 	delete que;

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

 	test.End();

 	}

 template<class T>

 void TestTQue<T>::Test8()

 	{

 	T* que;

 	TDeltaQueLink link1,link2,link3;

 	que=new T();

 	que->sDoAddDelta(&link1,1);

 	que->sDoAddDelta(&link2,3);

 	que->sDoAddDelta(&link3,6);

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

 	que->sDoRemoveFirst();

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

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

 	que->sDoRemoveFirst();

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

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

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

 	que->sDoRemoveFirst();

 	delete que;

 	}

 template<class T>

 void TestTQue<T>::Test9()

 	{

 	T* que;

 	TDblQueLink link1,link2;

 	TInt offset=4;

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

 	que=new VDblQue<TDblQueLink>(offset);

 	delete que;

 	que=new VDblQue<TDblQueLink>;

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

 	que->AddFirst(link1);

 	que->AddLast(link2);

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

 	que->IsHead(que->sHead);

 	que->IsFirst(&link1);

 	que->IsLast(&link2);

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

 	que->First();

 	que->Last();

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

 	delete que;

 	test.End();

 	}

 template<class T>

 void TestTQue<T>::Test10()

 	{

 	T* que;

 	TInt offset;

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

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

 		{

 		que=new VDblQue<TDblQueLink>(offset);

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

 		delete que;

 		}

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

 	test.End();

 	}

 template<class T>

 void TestTQue<T>::Test11()

 	{

 	T* que;

 	TDblQueLink link1,link2,link3,link4;

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

 	que=new T();

 	que->AddFirst(link1);

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

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

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

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

  	que->AddFirst(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->AddFirst(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->AddFirst(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->AddLast(link1);

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

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

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

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

 	que->AddLast(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->AddLast(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->AddLast(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->AddFirst(link1);

 	que->AddLast(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->AddFirst(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->AddLast(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;

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

 	test.End();

 	}

 template<class T>

 void TestTQue<T>::Test12()

 	{

 	T* que;

 	TDblQueLink link1,link2,link3,link4,*head;

 	que=new T();

 	que->AddFirst(link1);

  	que->AddLast(link2);

  	que->AddLast(link3);

   	que->AddLast(link4);

 	head=que->sHead;

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

 	test(que->IsHead(head)==TRUE);

 	test(que->IsHead(&link1)==FALSE);

 	test(que->IsHead(&link2)==FALSE);

 	test(que->IsHead(&link3)==FALSE);

 	test(que->IsHead(&link4)==FALSE);

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

 	test(que->IsFirst(head)==FALSE);

 	test(que->IsFirst(&link1)==TRUE);

 	test(que->IsFirst(&link2)==FALSE);

 	test(que->IsFirst(&link3)==FALSE);

 	test(que->IsFirst(&link4)==FALSE);

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

 	test(que->IsLast(head)==FALSE);

 	test(que->IsLast(&link1)==FALSE);

 	test(que->IsLast(&link2)==FALSE);

 	test(que->IsLast(&link3)==FALSE);

 	test(que->IsLast(&link4)==TRUE);

  	delete que;

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

 	test.End();

 	}

 template<class T>

 void TestTQue<T>::Test13()

 	{

 	T* que;

 	TDblQueLink link1,link2,link3,link4;

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

 	que=new T();

 	que->AddFirst(link1);

 	test(que->First()==&link1);

  	que->AddFirst(link2);

 	test(que->First()==&link2);

  	que->AddFirst(link3);

 	test(que->First()==&link3);

   	que->AddFirst(link4);

 	test(que->First()==&link4);

 	link1.Deque();

 	link2.Deque();

 	link3.Deque();

 	link4.Deque();

  	delete que;

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

 	que=new T();

 	que->AddLast(link1);

 	test(que->Last()==&link1);

  	que->AddLast(link2);

 	test(que->Last()==&link2);

  	que->AddLast(link3);

 	test(que->Last()==&link3);

   	que->AddLast(link4);

 	test(que->Last()==&link4);

 	link1.Deque();

 	link2.Deque();

 	link3.Deque();

 	link4.Deque();

  	delete que;

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

 	test.End();

 	}

 template<class T>

 void TestTQue<T>::Test14()

 	{

 	T* que;

 	TPriQueLink link;

 	TInt offset=4;

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

 	que=new VPriQue<TPriQueLink>(offset);

 	delete que;

 	que=new VPriQue<TPriQueLink>;

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

 	que->Add(link);

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

 	delete que;

 	test.End();

 	}

 template<class T>

 void TestTQue<T>::Test15()

 	{

 	T* que;

 	TInt offset;

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

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

 		{

 		que=new VPriQue<TPriQueLink>(offset);

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

 		delete que;

 		}

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

 	test.End();

 	}

 template<class T>

 void TestTQue<T>::Test16()

 	{

 	T* que;

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

 	que=new T();

 	link1.iPriority=4;

 	link2.iPriority=6;

 	link3.iPriority=2;

 	que->sDoAddPriority(&link1);

 	que->sDoAddPriority(&link2);

 	que->sDoAddPriority(&link3);

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

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

 	test(link1.iNext==&link3);

 	test(link1.iPrev==&link2);

 	test(link2.iNext==&link1);

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

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

 	test(link3.iPrev==&link1);

 	link4.iPriority=3;

 	que->sDoAddPriority(&link4);

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

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

 	test(link1.iNext==&link4);

 	test(link1.iPrev==&link2);

 	test(link2.iNext==&link1);

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

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

 	test(link3.iPrev==&link4);

 	test(link4.iNext==&link3);

 	test(link4.iPrev==&link1);

 	link5.iPriority=5;

 	que->sDoAddPriority(&link5);

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

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

 	test(link1.iNext==&link4);

 	test(link1.iPrev==&link5);

 	test(link2.iNext==&link5);

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

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

 	test(link3.iPrev==&link4);

 	test(link4.iNext==&link3);

 	test(link4.iPrev==&link1);

 	test(link5.iNext==&link1);

 	test(link5.iPrev==&link2);

 	link6.iPriority=1;

 	que->sDoAddPriority(&link6);

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

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

 	test(link1.iNext==&link4);

 	test(link1.iPrev==&link5);

 	test(link2.iNext==&link5);

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

 	test(link3.iNext==&link6);

 	test(link3.iPrev==&link4);

 	test(link4.iNext==&link3);

 	test(link4.iPrev==&link1);

 	test(link5.iNext==&link1);

 	test(link5.iPrev==&link2);

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

 	test(link6.iPrev==&link3);

 	delete que;

 	}

 template<class T>

 void TestTQue<T>::Test17()

 	{

 	T* que;

 	TDeltaQueLink link1,link2;

 	TInt offset=4;

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

 	que=new VDeltaQue<TDeltaQueLink>(offset);

 	delete que;

 	que=new VDeltaQue<TDeltaQueLink>;

 	test.Next(_L("Add/Remove"));

 	que->Add(link1,0);

 	que->Add(link2,2);

 	que->Remove(link2);

 	que->RemoveFirst();

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

 	test.End();

 	}

 template<class T>

 void TestTQue<T>::Test18()

 	{

 	T* que;

 	TInt offset;

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

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

 		{

 		que=new VDeltaQue<TDeltaQueLink>(offset);

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

 		delete que;

 		}

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

 	test.End();

 	}

 template<class T>

 void TestTQue<T>::Test19()

 	{

   	T* que;

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

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

 	que=new T();

 	que->Add(link2,3);

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

 	test(link2.iDelta==3);

 	que->Add(link5,15);

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

 	test(link2.iDelta==3);

 	test(link5.iDelta==12);

 	que->Add(link3,6);

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

 	test(link2.iDelta==3);

 	test(link3.iDelta==3);

 	test(link5.iDelta==9);

 	que->Add(link4,10);

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

 	test(link2.iDelta==3);

 	test(link3.iDelta==3);

 	test(link4.iDelta==4);

 	test(link5.iDelta==5);

 	que->Add(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->Add(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("Remove"));

 	que->Remove(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->Remove(link1);

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

 	test(link2.iDelta==3);

 	test(link3.iDelta==3);

 	test(link4.iDelta==4);

 	test(link5.iDelta==5);

 	que->Remove(link4);

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

 	test(link2.iDelta==3);

 	test(link3.iDelta==3);

 	test(link5.iDelta==9);

 	que->Remove(link3);

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

 	test(link2.iDelta==3);

 	test(link5.iDelta==12);

 	que->Remove(link5);

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

 	test(link2.iDelta==3);

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

 	test(NULL==que->RemoveFirst());

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

 	test(link2.iDelta==3);

 	link2.iDelta=1;

 	test(NULL==que->RemoveFirst());

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

 	test(link2.iDelta==1);

 	link2.iDelta=0;

 	test(&link2==que->RemoveFirst());

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

 	delete que;

 	test.End();

 	}

 class VDblQueIterBase : public TDblQueIterBase

 	{

 public:

 	VDblQueIterBase(TDblQueBase& aQue);

 	inline TAny* sDoPostInc() {return DoPostInc();}

 	inline TAny* sDoPostDec() {return DoPostDec();}

 	inline TAny* sDoCurrent() {return DoCurrent();}

 	TInt* sOffset;

 	TDblQueLinkBase** sHead;

 	TDblQueLinkBase** sNext;

 private:

 	void SetMember();

 	};

 template <class T>

 class VDblQueIter : public TDblQueIter<T>

 	{

 public:

 	VDblQueIter(TDblQueBase& aQue);

 	inline TAny* sDoPostInc() {return this->DoPostInc();}

 	inline TAny* sDoPostDec() {return this->DoPostDec();}

 	inline TAny* sDoCurrent() {return this->DoCurrent();}

 	TInt* sOffset;

 	TDblQueLinkBase** sHead;

 	TDblQueLinkBase** sNext;

 private:

 	void SetMember();

 	};

 VDblQueIterBase::VDblQueIterBase(TDblQueBase& aQue)

 	:TDblQueIterBase(aQue)

 	{

 	SetMember();

 	}

 void VDblQueIterBase::SetMember()

 	{

 	sOffset=&iOffset;

 	sHead=&iHead;

 	sNext=&iNext;

 	}

 template <class T>

 VDblQueIter<T>::VDblQueIter(TDblQueBase& aQue)

 	:TDblQueIter<T>(aQue)

 	{

 	SetMember();

 	}

 template <class T>

 void VDblQueIter<T>::SetMember()

 	{

 	sOffset=&this->iOffset;

 	sHead=&this->iHead;

 	sNext=&this->iNext;

 	}

 template<class T>

 class TestTQueIter

 	{

 public:

 	void TestIterBase();

 	void TestQueIter();

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

 	void Test2();	//Constructors

 	void Test3();	//Do's

 	void Test4();	//Set

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

 	void Test1Item();

 	//void Test6();	//Constructors										//Redundant

 	void Test7();	//Iterators

 private:

 	void CallTest2_4();

 	};

 template<class T>

 void TestTQueIter<T>::CallTest2_4()

 	{

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

 	Test2();

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

 	Test3();

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

 	Test4();

 	}

 template<class T>

 void TestTQueIter<T>::TestIterBase()

 	{

 	test.Start(_L("All Methods"));

 	Test1();

 	CallTest2_4();

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

 	test.End();

 	}

 template<class T>

 void TestTQueIter<T>::TestQueIter()

 	{

 	test.Start(_L("All Methods"));

 	Test5();

 	CallTest2_4();

 	test.Next(_L("One item in queue"));

 	Test1Item();

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

 	Test7();

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

 	test.End();

 	}

 template<class T>

 void TestTQueIter<T>::Test1()

 	{

 	Item item1,item2;

 	TDblQue<Item> que;

 	T* iter;

 	que.AddFirst(item2);

 	que.AddFirst(item1);

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

 	iter=new VDblQueIterBase(que);

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

 	iter->sDoCurrent();

 	iter->sDoPostInc();

 	iter->sDoPostDec();

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

 	iter->SetToFirst();

 	iter->SetToLast();

 	delete iter;

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

 	test.End();

 	}

 template<class T>

 void TestTQueIter<T>::Test2()

 	{

 	Item item;

 	TDblQue<Item>* que;

 	TInt offset;

  	T* iter;

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

 		{

 		que=new TDblQue<Item>(offset);

 		new(PtrAdd(&item.iLink,offset)) TDblQueLink();	// create the link at this offset

 		iter=new T(*que);

 		test(que->IsHead((Item*) PtrSub(*(iter->sHead),offset)));		//Need to pass a pointer to a item

 		test(que->IsHead((Item*) PtrSub(*(iter->sNext),offset)));

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

 		delete iter;

 		delete que;

 		que=new TDblQue<Item>(offset);

 		new(PtrAdd(&item.iLink,offset)) TDblQueLink();	// create the link at this offset

 		que->AddFirst(item);

 		iter=new T(*que);

 		test(que->IsHead((Item*) PtrSub(*(iter->sHead),offset)));

 		test(*(iter->sNext)==PtrAdd(&item.iLink,offset));						//Need a pointer to a link

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

 		PtrAdd(&item.iLink,offset)->Deque();

 		delete iter;

 		delete que;

 		}

 	}

 template<class T>

 void TestTQueIter<T>::Test3()

 	{

 	Item item1,item2,item3,item4;

 	TDblQue<Item> que;

  	T* iter;

 	que.AddFirst(item4);

 	que.AddFirst(item3);

 	que.AddFirst(item2);

 	que.AddFirst(item1);

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

 	iter=new T(que);

 	test(&item1==iter->sDoPostInc());

 	test(&item2.iLink==*(iter->sNext));

 	test(&item2==iter->sDoPostInc());

 	test(&item3.iLink==*(iter->sNext));

 	test(&item3==iter->sDoPostInc());

 	test(&item4.iLink==*(iter->sNext));

 	test(&item4==iter->sDoPostInc());

 	test(que.IsHead((Item*) *(iter->sNext)));

 	test(iter->sDoPostInc()==NULL);

 	delete iter;

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

 	iter=new T(que);

 	iter->sDoPostInc();

 	iter->sDoPostInc();

 	iter->sDoPostInc();

 	test(&item4.iLink==*(iter->sNext));

 	test(&item4==iter->sDoPostDec());

 	test(&item3.iLink==*(iter->sNext));

 	test(&item3==iter->sDoPostDec());

 	test(&item2.iLink==*(iter->sNext));

 	test(&item2==iter->sDoPostDec());

 	test(&item1.iLink==*(iter->sNext));

 	test(&item1==iter->sDoPostDec());

 	test(que.IsHead((Item*) *(iter->sNext)));

 	test(iter->sDoPostDec()==NULL);

 	delete iter;

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

 	iter=new T(que);

 	test(&item1==iter->sDoCurrent());

 	iter->sDoPostInc();

 	test(&item2==iter->sDoCurrent());

 	iter->sDoPostInc();

 	test(&item3==iter->sDoCurrent());

 	iter->sDoPostInc();

 	test(&item4==iter->sDoCurrent());

 	iter->sDoPostInc();

 	test(iter->sDoCurrent()==NULL);

 	delete iter;

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

 	test.End();

 	}

 template<class T>

 void TestTQueIter<T>::Test4()

 	{

 	Item item1,item2,item3,item4;

 	TDblQue<Item> que;

  	T* iter;

 	TInt i,j;

 	que.AddFirst(item4);

 	que.AddFirst(item3);

 	que.AddFirst(item2);

 	que.AddFirst(item1);

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

 	iter=new T(que);

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

 		{

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

 			iter->sDoPostInc();

 		iter->SetToFirst();

 		test(*(iter->sNext)==&item1.iLink);

 		}

 	delete iter;

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

 	iter=new T(que);

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

 		{

 		iter->SetToFirst();

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

 			iter->sDoPostInc();

 		iter->SetToLast();

 		test(*(iter->sNext)==&item4.iLink);

 		}

 	delete iter;

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

 	test.End();

 	}

 template<class T>

 void TestTQueIter<T>::Test5()

 	{

 	Item item1,item2;

 	TDblQue<Item> que;

 	T* iter;

 	Item* a;

 	que.AddFirst(item2);

 	que.AddFirst(item1);

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

 	iter=new T(que);

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

 	a=*iter;

 	test(((*iter)++)==&item1);

 	test(((*iter)--)==&item2);

 	test(((*iter)++)==&item1);

 	test(((*iter)++)==&item2);

 	test(((*iter)++)==NULL);

 	test(((*iter)++)==NULL);

 	test(((*iter)--)==NULL);

 	test(((*iter)--)==NULL);

 	iter->Set(item2);

 	test(((*iter)--)==&item2);

 	test(((*iter)++)==&item1);

 	test(((*iter)--)==&item2);

 	test(((*iter)--)==&item1);

 	test(((*iter)++)==NULL);

 	test(((*iter)++)==NULL);

 	test(((*iter)--)==NULL);

 	test(((*iter)--)==NULL);

 	delete iter;

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

 	test.End();

 	}

 template<class T>

 void TestTQueIter<T>::Test1Item()

 	{

 	Item item;

 	TDblQue<Item> que;

 	T* iter;

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

 	iter=new T(que);

 	que.AddFirst(item);

 	iter->Set(item);	

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

 	test(((*iter)++)==&item);

 	test(((*iter)++)==NULL);

 	test(((*iter)++)==NULL);

 	test(((*iter)++)==NULL);

 	test(((*iter)--)==NULL);

 	test(((*iter)--)==NULL);

 	iter->Set(item);	

 	test(((*iter)--)==&item);

 	test(((*iter)++)==NULL);

 	test(((*iter)--)==NULL);

 	test(((*iter)--)==NULL);

 	test(((*iter)--)==NULL);

 	test(((*iter)++)==NULL);

 	test(((*iter)++)==NULL);

 	delete iter;

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

 	test.End();

 	}

 /*template<class T>					//Redundant

 void TestTQueIter<T>::Test6()

 	{

 	Item item;

 	TDblQue<Item>* que;

 	TInt offset;

  	T* iter;

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

 		{

 		que=new TDblQue<Item>(offset);

 		iter=new T(*que);

 		test(que->IsHead((Item*) *(iter->sHead)));

 		test(que->IsHead((Item*) *(iter->sNext)));

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

 		delete iter;

 		delete que;

 		que=new TDblQue<Item>(offset);

 		que->AddFirst(item);

 		iter=new T(*que);

 		test(que->IsHead((Item*) *(iter->sHead)));

 		test(*(iter->sNext)==&item.iLink);

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

 		delete iter;

 		delete que;

 		}

 	}*/

 template<class T>

 void TestTQueIter<T>::Test7()

 	{

 	Item item1,item2,item3,item4;

 	TDblQue<Item> que;

  	T* iter;

 	que.AddFirst(item4);

 	que.AddFirst(item3);

 	que.AddFirst(item2);

 	que.AddFirst(item1);

 	test.Start(_L("PostFix ++"));

 	iter=new T(que);

 	test(&item1==(*iter)++);

 	test(&item2.iLink==*(iter->sNext));

 	test(&item2==(*iter)++);

 	test(&item3.iLink==*(iter->sNext));

 	test(&item3==(*iter)++);

 	test(&item4.iLink==*(iter->sNext));

 	test(&item4==(*iter)++);

 	test(que.IsHead((Item*) *(iter->sNext)));

 	test((*iter)++==NULL);

 	delete iter;

 	test.Next(_L("PostFix --"));

 	iter=new T(que);

 	iter->SetToLast();

 	test(&item4.iLink==*(iter->sNext));

 	test(&item4==(*iter)--);

 	test(&item3.iLink==*(iter->sNext));

 	test(&item3==(*iter)--);

 	test(&item2.iLink==*(iter->sNext));

 	test(&item2==(*iter)--);

 	test(&item1.iLink==*(iter->sNext));

 	test(&item1==(*iter)--);

 	test(que.IsHead((Item*) *(iter->sNext)));

 	test((*iter)--==NULL);

 	delete iter;

 	test.Next(_L("Conversion Operator"));

 	iter=new T(que);

 	test(&item1==*iter);

 	(*iter)++;

 	test(&item2==*iter);

 	(*iter)++;

 	test(&item3==*iter);

 	(*iter)++;

 	test(&item4==*iter);

 	(*iter)++;

 	test(*iter==NULL);

 	delete iter;

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

 	test.End();

 	}

 GLDEF_C TInt E32Main()

     {

 	TestTQueLink<TDblQueLinkBase>* testDblQueLinkBase;

 	TestTQueLink<TDeltaQueLink>* testDeltaQueLink;

 	TestTQueLink<TDblQueLink>* testDblQueLink;

 	TestTQueLink<TPriQueLink>* testPriQueLink;

 	TestTQue<VDblQueBase>* testDblQueBase;

 	TestTQue<VDeltaQueBase>* testDeltaQueBase;

 	TestTQue<VDblQue<TDblQueLink> >* testDblQue;

 	TestTQue<VPriQue<TPriQueLink> >* testPriQue;

  	TestTQue<VDeltaQue<TDeltaQueLink> >* testDeltaQue;

 	TestTQueIter<VDblQueIterBase>* testDblQueIterBase;

 	TestTQueIter<VDblQueIter<Item> >* testDblQueIter;

 // Test the queue classes.

 	test.Title();

 	test.Start(_L("class TDblQueLinkBase"));

 	testDblQueLinkBase=new TestTQueLink<TDblQueLinkBase>;

 	testDblQueLinkBase->TestQueLinkBase();

 	delete testDblQueLinkBase;

 	test.Next(_L("class TDeltaQueLink"));

 	testDeltaQueLink=new TestTQueLink<TDeltaQueLink>;

 	testDeltaQueLink->TestQueLinkBase();

 	delete testDeltaQueLink;

   	test.Next(_L("class TDblQueLink"));

 	testDblQueLink=new TestTQueLink<TDblQueLink>;

 	testDblQueLink->TestQueLink();

 	delete testDblQueLink;

   	test.Next(_L("class TPriQueLink"));

 	testPriQueLink=new TestTQueLink<TPriQueLink>;

 	testPriQueLink->TestQueLink();

  	delete testPriQueLink;

 	test.Next(_L("class TDblQueBase"));

 	testDblQueBase=new TestTQue<VDblQueBase>;

 	testDblQueBase->TestQueBase();

  	delete testDblQueBase;

 	test.Next(_L("class TDeltaQueBase"));

 	testDeltaQueBase=new TestTQue<VDeltaQueBase>;

 	testDeltaQueBase->TestDeltaBase();

  	delete testDeltaQueBase;

 	test.Next(_L("class TDlbQue"));

 	testDblQue=new TestTQue<VDblQue<TDblQueLink> >;

 	testDblQue->TestDblQue();

  	delete testDblQue;

 	test.Next(_L("class TPriQue"));

 	testPriQue=new TestTQue<VPriQue<TPriQueLink> >;

 	testPriQue->TestPriQue();

  	delete testPriQue;

 	test.Next(_L("class TDeltaQue"));

 	testDeltaQue=new TestTQue<VDeltaQue<TDeltaQueLink> >;

 	testDeltaQue->TestDeltaQue();

  	delete testDeltaQue;

 	test.Next(_L("class TDblQueIterBase"));

 	testDblQueIterBase=new TestTQueIter<VDblQueIterBase>;

 	testDblQueIterBase->TestIterBase();

  	delete testDblQueIterBase;

 	test.Next(_L("class TDblQueIter"));

 	testDblQueIter=new TestTQueIter<VDblQueIter<Item> >;

 	testDblQueIter->TestQueIter();

  	delete testDblQueIter;

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

 	test.End();

 	return(0);

     }

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