// 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_sque.cpp

// Overview:

// Test single linked list functionality.

// API Information:

// TSglQueLink, TSglQueBase.

// Details:

// - Create specified number of TSglQueLink objects, then delete them. 

// - Create TSglQueBase object with specified offset and without an offset,

// add and remove links to the list, check that the list is empty.

// - Create TSglQueBase object with and without an offset, verify offset, head 

// and last member values are correct.

// - Create TSglQueBase object, insert links using DoAddFirst and DoAddLast and

// remove links using DoRemove, check the results are as expected.

// - Create TSglQueBase object, insert links using DoAddFirst and DoAddLast and

// verify IsEmpty return the correct value. Set and verify the offset.

// - Create TSglQue object, insert TSglQueLink link at front and end of list, test 

// whether the links are inserted at specified location, remove some links.

// - Create TSglQue object, insert links using DoAddFirst and DoAddLast and

// remove links using DoRemove, check the results are as expected.

// - Create TSglQue object, insert links using DoAddFirst and DoAddLast and

// verify IsEmpty return the correct value. Set and verify the offset.

// - Create TSglQue object with and without an offset, verify offset, head 

// and last member values are correct.

// - Create TSglQue object, insert links using AddFirst and AddLast and

// verify results are as expected.

// - Create TSglQue object, insert links using AddFirst and AddLast and

// verify results using IsFirst and IsLast are as expected.

// - Create TSglQue object, insert links using AddFirst and AddLast and

// verify results using First and Last are as expected.

// - Create TSglQue object, insert links using AddLast and delete using Remove,

// verify results are as expected.

// - Create TSglQueIterBase object, with and without an offset, call the 

// DoCurrent, DoPostInc and SetToFirst methods.

// - Create TSglQueIterBase object, with and without an offset, and TSglQue 

// with different offsets, verify results are as expected.

// - Create TSglQueIterBase object, , with and without an offset, use the 

// DoCurrent and DoPostInc methods and verify the results are as expected.

// - Create TSglQueIterBase object, , with and without an offset, use the 

// DoPostInc and SetToFirst methods and verify the results are as expected.

// - Create TSglQueIter object, with and without an offset, iterate using 

// the ++ operator and delete the object.

// - Create TSglQueIter object, with and without an offset, and TSglQue 

// object with different offsets, verify results are as expected.

// - Create TSglQueIter object, with and without an offset, use the 

// DoCurrent and DoPostInc methods and verify the results are as expected.

// - Create TSglQueIter object, with and without an offset, use the 

// DoPostInc and SetToFirst methods and verify the results are as expected.

// - Create TSglQueIter object, with and without an offset, iterate using 

// the ++ operator, use the conversion operator, verify the results are 

// as expected.

// Platforms/Drives/Compatibility:

// All 

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32base.h>

#include <e32test.h>

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

#define SIZE 10

#define MAX_OFFSET 10

struct Item

	{

	TSglQueLink iLink;

	TInt iSpace[MAX_OFFSET]; // Reserve some space

	};

struct ItemWithOffset

	{

	TInt iSpace[MAX_OFFSET];

	TSglQueLink iLink;

	};

template<class T>

class TestTQueLink

	{

public:

	void TestQueLink();	// Calls Test: 1

	void Test1();

protected:

	void CreateObjects(TInt aBaseLink);

	void DestroyObjects();

private:

	T* iLink[SIZE];

	};

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];

	}

template<class T>

void TestTQueLink<T>::DestroyObjects()

	{

	TInt i;

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

		delete iLink[i];

	}

template <class T>

void TestTQueLink<T>::TestQueLink()

	{

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

	Test1();

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

	test.End();

	}

template<class T>

void TestTQueLink<T>::Test1()

	{

	test.Start(_L("Create objects"));

	CreateObjects(1);

	test.Next(_L("Destroy objects"));

	DestroyObjects();

	test.End();

	}

class VSglQueBase : public TSglQueBase

	{

public:

	inline VSglQueBase();

	inline VSglQueBase(TInt anOffset);

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

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

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

public:

	TSglQueLink** sHead;

	TSglQueLink** sLast;

	TInt* sOffset;

private:

	void SetMembers();

	};

template <class T>

class VSglQue : public TSglQue<T>

	{

public:

	inline VSglQue();

	inline VSglQue(TInt anOffset);

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

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

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

public:

	TSglQueLink** sHead;

	TSglQueLink** sLast;

	TInt* sOffset;

private:

	void SetMembers();

	};

inline VSglQueBase::VSglQueBase()

	{

	SetMembers();

	}

inline VSglQueBase::VSglQueBase(TInt anOffset)

	:TSglQueBase(anOffset)

	{

	SetMembers();

	}

void VSglQueBase::SetMembers()

	{

	sHead=&iHead;

	sLast=&iLast;

	sOffset=&iOffset;

	}

template <class T>

VSglQue<T>::VSglQue()

	{

	SetMembers();

	}

template <class T>

VSglQue<T>::VSglQue(TInt anOffset)

	:TSglQue<T>(anOffset)

	{

	SetMembers();

	}

template <class T>

void VSglQue<T>::SetMembers()

	{

	sHead=&this->iHead;

	sLast=&this->iLast;

	sOffset=&this->iOffset;

	}

template<class T>

class TestTQue

	{

public:

	void TestQueBase();

	void TestSglQue();

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

	void Test2();	// Constructors

	void Test3();	// DoAdd's

	void Test4();	// Public functions

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

	//void Test6();	// Constructors

	void Test7();	// Add's

	void Test8();	// Is's

	void Test9();	// Get's

	void Test10();	// Add's

private:

	void CallTest3_4();	

	};

template<class T>

void TestTQue<T>::CallTest3_4()

	{

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

	Test3();

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

	Test4();

	}

template<class T>

void TestTQue<T>::TestQueBase()

	{

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

	Test1();						 

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

	Test2();

	CallTest3_4();

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

	test.End();

	}

template<class T>

void TestTQue<T>::TestSglQue()

	{

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

	Test5();

	test.Next(_L("Test Super Class functions"));

	CallTest3_4();

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

	Test2();

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

	Test7();

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

	Test8();

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

	Test9();

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

	Test10();

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

	test.End();

	}

template<class T>

void TestTQue<T>::Test1()

	{

	T* que;

	TSglQueLink link1,link2;

	TInt offset=4;

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

	que=new VSglQueBase(offset);

	delete que;

	que=new VSglQueBase;

	//delete que;

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

	que->sDoAddFirst(&link1);

	que->sDoAddLast(&link2);

	que->sDoRemove(&link1);

	que->sDoRemove(&link2);

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

	que->IsEmpty();

	que->SetOffset(offset);

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

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

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

	test(*(que->sLast)==(TSglQueLink*) que->sHead);

	delete que;

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

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

		{

		que=new T(offset);

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

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

		test(*(que->sLast)==(TSglQueLink*) que->sHead);

		delete que;

		}

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

	test.End();

	}

template<class T>

void TestTQue<T>::Test3()

	{

	T* que;

		{

		TSglQueLink link1,link2,link3,link4;

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

		que=new T();

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

		test(*(que->sLast)==(TSglQueLink*) que->sHead);

		que->sDoAddFirst(&link1);

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

		test(*(que->sLast)==&link1);

		test(link1.iNext==NULL);

		que->sDoAddFirst(&link2);

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

		test(*(que->sLast)==&link1);

		test(link1.iNext==NULL);

		test(link2.iNext==&link1);

		que->sDoAddFirst(&link3);

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

		test(*(que->sLast)==&link1);

		test(link1.iNext==NULL);

		test(link2.iNext==&link1);

		test(link3.iNext==&link2);

		que->sDoAddFirst(&link4);

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

		test(*(que->sLast)==&link1);

		test(link1.iNext==NULL);

		test(link2.iNext==&link1);

		test(link3.iNext==&link2);

		test(link4.iNext==&link3);

		delete que;

		}

	TSglQueLink link1,link2,link3,link4;

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

	que=new T();

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

	test(*(que->sLast)==(TSglQueLink*) que->sHead);

	que->sDoAddLast(&link1);

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

	test(*(que->sLast)==&link1);

	test(link1.iNext==NULL);

	que->sDoAddLast(&link2);

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

	test(*(que->sLast)==&link2);

	test(link1.iNext==&link2);

	test(link2.iNext==NULL);

	que->sDoAddLast(&link3);

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

	test(*(que->sLast)==&link3);

	test(link1.iNext==&link2);

	test(link2.iNext==&link3);

	test(link3.iNext==NULL);

	que->sDoAddLast(&link4);

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

	test(*(que->sLast)==&link4);

	test(link1.iNext==&link2);

	test(link2.iNext==&link3);

	test(link3.iNext==&link4);

	test(link4.iNext==NULL);

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

	que->sDoRemove(&link3);

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

	test(*(que->sLast)==&link4);

	test(link1.iNext==&link2);

	test(link2.iNext==&link4);

	test(link4.iNext==NULL);

	que->sDoRemove(&link4);

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

	test(*(que->sLast)==&link2);

	test(link1.iNext==&link2);

	test(link2.iNext==NULL);

	que->sDoRemove(&link1);

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

	test(*(que->sLast)==&link2);

	test(link2.iNext==NULL);

	que->sDoRemove(&link2);

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

	test(*(que->sLast)==(TSglQueLink*) que->sHead);

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

	TSglQueLink link1,link2;

	que->sDoAddFirst(&link1);

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

	que->sDoRemove(&link1);

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

	que->sDoAddLast(&link2);

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

	que->sDoAddFirst(&link1);

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

	que->sDoRemove(&link2);

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

	que->sDoRemove(&link1);

	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;

	TSglQueLink link1,link2;

	TInt offset=4;

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

	que=new VSglQue<TSglQueLink>(offset);

	delete que;

	que=new VSglQue<TSglQueLink>;

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

	que->AddFirst(link1);

	que->AddLast(link2);

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

	que->IsFirst(&link1);

	que->IsLast(&link1);

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

	que->First();

	que->Last();

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

	que->Remove(link1);

	que->Remove(link2);

	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 VSglQue<TSglQueBase>();

	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;

		{

		TSglQueLink link1,link2,link3,link4;

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

		que=new T();

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

		test(*(que->sLast)==(TSglQueLink*) que->sHead);

		que->AddFirst(link1);

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

		test(*(que->sLast)==&link1);

		test(link1.iNext==NULL);

		que->AddFirst(link2);

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

		test(*(que->sLast)==&link1);

		test(link1.iNext==NULL);

		test(link2.iNext==&link1);

		que->AddFirst(link3);

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

		test(*(que->sLast)==&link1);

		test(link1.iNext==NULL);

		test(link2.iNext==&link1);

		test(link3.iNext==&link2);

		que->AddFirst(link4);

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

		test(*(que->sLast)==&link1);

		test(link1.iNext==NULL);

		test(link2.iNext==&link1);

		test(link3.iNext==&link2);