// Copyright (c) 2008-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:

//

#include <kernel/kern_priv.h>

#include "d_newldd.h"

#include "t_newldd.h"

TInt DOperatorNewTest::Request(TInt aReqNo, TAny* /*a1*/, TAny* /*a2*/)

	{

	switch(aReqNo)

		{

		//new

		case RNewLddTest::ENew:

			{

			return TestNew();

			}

		//placement new

		case RNewLddTest::EPlacementVectorNew:

			{

			return TestPlacementVectorNew();

			}

		//vector new

		case RNewLddTest::EVectorNew:

			{

			return TestVectorNew();

			}

		case RNewLddTest::EPlacementNew:

			{

			return TestPlacementNew();

			}

		default:

			break;

		}

	return KErrNone;

	}

TInt DOperatorNewTest::TestNew()

	{

	Kern::Printf("::TestNew()");

	NKern::ThreadEnterCS();

	#define TEST_KERN_NEW_OOM(CLASS)\

		{\

		Kern::Printf("new " #CLASS);\

		CLASS* p##CLASS=NULL;\

		XTRAPD(r,XT_DEFAULT, p##CLASS = new CLASS);\

		if(r!=KErrNone)\

			{\

			NKern::ThreadLeaveCS();\

			return r;\

			}\

		if(p##CLASS)\

			{\

			delete p##CLASS;\

			NKern::ThreadLeaveCS();\

			return KErrGeneral;\

			}\

		}

	//OOM tests: should(must) not throw

	Kern::Printf("OOM Tests;");

	TEST_KERN_NEW_OOM(XVeryLargeClassCtorAndDtor);

	TEST_KERN_NEW_OOM(XVeryLargeClassCtorOnly);

	TEST_KERN_NEW_OOM(XVeryLargeClassDtorOnly);

	TEST_KERN_NEW_OOM(XVeryLargeClassNoTors);

	Kern::Printf("non-OOM Tests;");

	//Non-OOM:

	#define TEST_KERN_NEW(CLASS, TEST_CTOR)\

		{\

		Kern::Printf("new " #CLASS);\

		CLASS* p##CLASS=NULL;\

		XTRAPD(r,XT_DEFAULT, p##CLASS = new CLASS);\

		if(r!=KErrNone)\

			{\

			NKern::ThreadLeaveCS();\

			return r;\

			}\

		if(p##CLASS==NULL)\

			{\

			NKern::ThreadLeaveCS();\

			return KErrGeneral;\

			}\

		volatile TBool testCtor=(TEST_CTOR);\

		if(testCtor && (p##CLASS->iState!=EConstructed) )\

			{\

			r=KErrGeneral;\

			}\

		delete p##CLASS;\

		p##CLASS=NULL;\

		if(r!=KErrNone)\

			return r;\

		}

	TEST_KERN_NEW(XCtorAndDtor, ETrue);

	TEST_KERN_NEW(XCtorOnly, ETrue);

	TEST_KERN_NEW(XDtorOnly, EFalse);

	TEST_KERN_NEW(XNoTors, EFalse);

	NKern::ThreadLeaveCS();

	return KErrNone;

	}

TInt DOperatorNewTest::TestPlacementNew()

	{

	Kern::Printf("::TestPlacementNew");

	#define TEST_KERN_PLACEMENT_NEW(CLASS, POST_CTOR, POST_DTOR) \

		{\

		Kern::Printf("new(someram) " #CLASS);\

		NKern::ThreadEnterCS();\

		void* someram = Kern::AllocZ(sizeof(CLASS));\

		NKern::ThreadLeaveCS();\

		if(!someram)\

			return KErrNoMemory;\

		\

		CLASS* p##CLASS = new (someram) CLASS;\

		TInt r=KErrNone;\

		if(p##CLASS->iState != POST_CTOR)\

			{\

			r=KErrGeneral;\

			}\

		if(r==KErrNone)\

			{\

			p##CLASS->~CLASS();\

			if(p##CLASS->iState != POST_DTOR)\

				{\

				r=KErrGeneral;\

				}\

			}\

		NKern::ThreadEnterCS();\

		Kern::Free(someram);\

		NKern::ThreadLeaveCS();\

		if(r != KErrNone)\

			return r;\

		}

	TEST_KERN_PLACEMENT_NEW(XCtorAndDtor, EConstructed, EDeconstructed);

	TEST_KERN_PLACEMENT_NEW(XCtorOnly, EConstructed, EConstructed);

	TEST_KERN_PLACEMENT_NEW(XDtorOnly, ENull, EDeconstructed);

	TEST_KERN_PLACEMENT_NEW(XNoTors, ENull, ENull);

	return KErrNone;

	}

TInt DOperatorNewTest::TestPlacementVectorNew()

	{

	Kern::Printf("::TestPlacementVectorNew");

	//for vector placement new, emulator compilers 

	//allocate a cookie at start of buffer.

	//this seems wrong since the cookie is an internal compiller

	//detail which the user should not need to know about

	#if defined(__WINSCW__) || defined(__VC32__)

	Kern::Printf("Not running on emulator. WINSCW and Visual studio\n insert a cookie for placement vector new"); 

	#else

	#define TEST_KERN_PLACEMENT_VECTOR_NEW(CLASS, ARRAY_LENGTH, POST_CTOR, POST_DTOR) \

		{\

		NKern::ThreadEnterCS();\

		void* someram = Kern::AllocZ(sizeof(CLASS) * (ARRAY_LENGTH));\

		NKern::ThreadLeaveCS();\

		if(someram==NULL)\

			return KErrNoMemory;\

		\

		TInt r = KErrNone;\

		Kern::Printf("new (someram) " #CLASS "[%d]", ARRAY_LENGTH);\

		\

		CLASS* p##CLASS = new (someram) CLASS[ARRAY_LENGTH];\

		for(TInt i=0; i<(ARRAY_LENGTH); ++i)\

			{\

			if(p##CLASS[i].iState != POST_CTOR)\

				{\

				r=KErrGeneral;\

				break;\

				}\

			p##CLASS[i].~CLASS();\

			if(p##CLASS[i].iState != POST_DTOR)\

				{\

				r=KErrGeneral;\

				break;\

				}\

			}\

		NKern::ThreadEnterCS();\

		Kern::Free(someram);\

		NKern::ThreadLeaveCS();\

		if(r!=KErrNone)\

			return r;\

		}\

	TEST_KERN_PLACEMENT_VECTOR_NEW(XCtorAndDtor, KTestArrayLength, EConstructed, EDeconstructed);

	TEST_KERN_PLACEMENT_VECTOR_NEW(XCtorOnly, KTestArrayLength, EConstructed, EConstructed);

	TEST_KERN_PLACEMENT_VECTOR_NEW(XDtorOnly, KTestArrayLength, ENull, EDeconstructed);

	TEST_KERN_PLACEMENT_VECTOR_NEW(XNoTors, KTestArrayLength, ENull, ENull);

	#endif

	return KErrNone;

	}

TInt DOperatorNewTest::TestVectorNew()

	{

	//OOM testing

	Kern::Printf("::TestVectorNew()");

	Kern::Printf("OOM test");

	TInt r=KErrNone;

	#define TEST_KERN_VECTOR_NEW_OOM(CLASS, ARRAY_LENGTH)\

	{\

		Kern::Printf("new " #CLASS "[%d]", ARRAY_LENGTH);\

		CLASS* p##CLASS = NULL;\

		NKern::ThreadEnterCS();\

		XTRAP(r,XT_DEFAULT,p##CLASS = new CLASS[ARRAY_LENGTH]; );\

		if(p##CLASS)\

			{\

			r=KErrGeneral;\

			delete p##CLASS;\

			}\

		NKern::ThreadLeaveCS();\

		if(r!=KErrNone)\

			{\

			return r;\

			}\

	}\

	TEST_KERN_VECTOR_NEW_OOM(XCtorAndDtor, KOOMArraySize);

	TEST_KERN_VECTOR_NEW_OOM(XCtorOnly, KOOMArraySize);

	TEST_KERN_VECTOR_NEW_OOM(XDtorOnly, KOOMArraySize);

	TEST_KERN_VECTOR_NEW_OOM(XNoTors, KOOMArraySize);

	//non-OOM:

	Kern::Printf("non-OOM test");

	#define TEST_KERN_VECTOR_NEW(CLASS, ARRAY_LENGTH, TEST_CTOR)\

	{\

		Kern::Printf("new " #CLASS "[%d]", ARRAY_LENGTH);\

		CLASS* p##CLASS = NULL;\

		NKern::ThreadEnterCS();\

		XTRAP(r,XT_DEFAULT,p##CLASS = new CLASS[ARRAY_LENGTH]; );\

		NKern::ThreadLeaveCS();\

		if(p##CLASS == NULL)\

			{\

			return KErrNoMemory;\

			}\

		\

		TBool testCtor=(TEST_CTOR);\

		if(testCtor)\

			{\

			for(TInt i=0; i<(ARRAY_LENGTH); ++i)\

				{\

				if(p##CLASS[i].iState!=	EConstructed)\

					{\

					r=KErrGeneral;\

					break;\

					}\

				}\

			}\

		\

		NKern::ThreadEnterCS();\

		delete[] p##CLASS;\

		NKern::ThreadLeaveCS();\

		p##CLASS=NULL;\

		if(r!=KErrNone)\

			{\

			return r;\

			}\

	}\

	TEST_KERN_VECTOR_NEW(XCtorAndDtor, KTestArrayLength, ETrue);

	TEST_KERN_VECTOR_NEW(XCtorOnly, KTestArrayLength, ETrue);

	TEST_KERN_VECTOR_NEW(XDtorOnly, KTestArrayLength, EFalse);

	TEST_KERN_VECTOR_NEW(XNoTors, KTestArrayLength, EFalse);

	return KErrNone;

	}

TInt DOperatorNewTestFactory::Create(DLogicalChannelBase*& aChannel)

//

// Create a new DTest on this logical device

//

	{

	aChannel=new DOperatorNewTest();

	return aChannel?KErrNone:KErrNoMemory;

	}

TInt DOperatorNewTestFactory::Install()

//

// Install the LDD - overriding pure virtual

//

	{

	iVersion = TVersion(0,1,1);

	return SetName(&KLddName);

	}

void DOperatorNewTestFactory::GetCaps(TDes8& /*aDes*/) const

//

// Get capabilities - overriding pure virtual

//

	{

	//not supported

	}

DECLARE_STANDARD_LDD()

	{

	//create factory here.

	return new DOperatorNewTestFactory;

	}