// Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).

// e32test\dmav2\t_dma2.cpp

// SelfTest option

//Verbose option

//Simple transfer test option

_LIT(KArgSimpleTest, "/simple"); 

//Callback test option

_LIT(KArgCallBackTest, "/callback");

//Suspend test option

_LIT(KArgSuspendTest, "/suspend");

//Multipart transfer tests

_LIT(KArgMultiPartTest, "/multi");

//Isr and dfc test option

_LIT(KArgIsrDfcTest, "/isrdfc");

//Isr reque  test option

_LIT(KArgIsrequeTest, "/isreque");

//Benchmark test option

_LIT(KArgBenchmarkTest, "/bench");

//Graphics test option

_LIT(KArgGraphicTest, "/graphic");

//DMA channel (opening and closing)  test option

_LIT(KArgChannelTest, "/channel");

//Queue test option

_LIT(KArgQueueTest, "/queue");

//Fragment test option

_LIT(KArgFragmentTest, "/fragment");

//Request test option

_LIT(KArgRequestTest, "/request");

TBool gSimpleTest;		// run only Simple transfer test

TBool gCallBack;		// run only Callback test

TBool gSuspend;			// run only Pause and resume tests

TBool gIsrReque;		// run only IsrReque tests

TBool gMultiPart;		// run only Multipart tests

TBool gIsrAndDfc;		// run only IsrAndDfc tests

TBool gBenchmark;		// run only Benchmark tests

TBool gGraphic;			// run only Graphic tests

TBool gFragment;		// run only Fragment related tests

TBool gChannel;			// run only Channel(open/close)tests

TBool gQueue;			// run only Queue related tests

TBool gRequest;			// run only Request related tests

	// Only open a new session if one

	// was not already supplied

	if(iDmaSession.Handle() == KNullHandle)

		{

		TInt r = iDmaSession.Open();

		TEST_ASSERT(r == KErrNone);

		r = iDmaSession.OpenSharedChunk(iChunk);

		TEST_ASSERT(r == KErrNone);

		}

	}

// Open another handle to the test driver

void CDmaTest::OpenDmaSession(const RDmaSession& aSession)

	{

	iDmaSession = aSession;

	TInt r = iDmaSession.Duplicate(RThread(), EOwnerThread);

	// open another handle to the test driver chunk

void CDmaTest::PreTransferSetup()

	{

	}

TInt CDmaTest::DoPostTransferCheck()

	{

	return KErrNotSupported;

	}

void CDmaTest::ChannelPause(TUint aChannelSessionCookie)

{

	TInt r = iDmaSession.ChannelPause(aChannelSessionCookie);

	TEST_ASSERT(r == KErrNone);

}

void CDmaTest::ChannelResume(TUint aChannelSessionCookie)

{

	TInt r = iDmaSession.ChannelResume(aChannelSessionCookie);

	TEST_ASSERT(r == KErrNone);

}

			iDmaSession.RequestCreate(iChannelSessionCookie, iRequestSessionCookie, iMaxFragmentSize);

			iDmaSession.RequestCreateOld(iChannelSessionCookie, iRequestSessionCookie, iMaxFragmentSize);

void CSingleTransferTest::PrintTestInfo() const

	{

	CDmaTest::PrintTestInfo();

	// State which API versions are being used

	if(iUseNewFragment)

		RDebug::RawPrint(_L(", Fragment v2,"));

	else

		RDebug::RawPrint(_L(", Fragment v1,"));

	if(iUseNewRequest)

		RDebug::RawPrint(_L(" DDmaRequest v2"));

	else

		RDebug::RawPrint(_L(" DDmaRequest v1"));

	}

//////////////////////////////////////////////////////////////////////

// CDmaTestDecorator

//////////////////////////////////////////////////////////////////////

CDmaTestDecorator::CDmaTestDecorator(CDmaTest* aDecoratedTest)

	: CDmaTest(_L("Decorated Test"), 1, NULL, NULL), iDecoratedTest(aDecoratedTest)

	{}

CDmaTestDecorator::CDmaTestDecorator(const CDmaTestDecorator& aOther)

	: CDmaTest(aOther), iDecoratedTest( static_cast<CDmaTest*>( aOther.iDecoratedTest->Clone() ) )

	// Need cast because Clone does not have a covariant return type,

	// as not all compillers allow it

	{}

//////////////////////////////////////////////////////////////////////

// CMultiVersionTest

//////////////////////////////////////////////////////////////////////

CMultiVersionTest::CMultiVersionTest(CSingleTransferTest* aDmaTest)

	: CDmaTestDecorator(aDmaTest), iNewVersionTest(NULL)

	{

	}

CMultiVersionTest::CMultiVersionTest(const CMultiVersionTest& aOther)

	: CDmaTestDecorator(aOther), iNewVersionTest( aOther.iNewVersionTest ? static_cast<CSingleTransferTest*>(aOther.iNewVersionTest->Clone()) : NULL)

	{

	}

CMultiVersionTest::~CMultiVersionTest()

	{

	delete iDecoratedTest;

	delete iNewVersionTest;

	}

void CMultiVersionTest::SetupL()

	{

	// Open a tempory dma session to find out the

	// capabilities of the dma channel.

	OpenDmaSession();

	Configure();

	CloseDmaSession();

	}

void CMultiVersionTest::Announce() const

	{

	CTest::Announce();

	iDecoratedTest->Announce();

	if(iNewVersionTest)

		iNewVersionTest->Announce();

	}

void CMultiVersionTest::PrintTestType() const

	{

	RDebug::RawPrint(_L("Multi version test wrapper"));

	}

void CMultiVersionTest::PrintTestInfo() const

	{

		if(iNewVersionTest)

			{ 		

			RDebug::RawPrint(_L("Running tests using Version 2 PIL"));

			}

		else

			{

			RDebug::RawPrint(_L("Running tests using Version 1 PIL"));		

			}

	}

void CMultiVersionTest::RunTest()

	{

	OpenDmaSession();

	// iDecoratedTest is the test, in the old configuration

	// iNewVersionTest is the same test, configured

	// to use the new APIs

	//

	// 2 objects are needed since they can each store

	// their own results

	iDecoratedTest->OpenDmaSession(iDmaSession);

	(*iDecoratedTest)();

	if(iNewVersionTest)

		{

		iNewVersionTest->OpenDmaSession(iDmaSession);

		(*iNewVersionTest)();

		}

	CloseDmaSession();

	}

/**

Maybe create another test object to run with new API

Pass on the cookie for the channel they must test

*/

void CMultiVersionTest::Configure()

	{

	static_cast<CSingleTransferTest*>(iDecoratedTest)->UseNewDmaApi(EFalse);

	iDecoratedTest->SetChannelCookie(iChannelCookie);

	if(Version2PILAvailable())

		{

		iNewVersionTest = static_cast<CSingleTransferTest*>(iDecoratedTest->Clone());

		TEST_ASSERT(iNewVersionTest != NULL);

		iNewVersionTest->UseNewDmaApi(ETrue);

		iNewVersionTest->SetChannelCookie(iChannelCookie);

		}

	}

/**

Discover from DMA channel what PIL versions are available.

In practice V1 APIs will always be available, V2 may be.

*/

TBool CMultiVersionTest::Version2PILAvailable()

	{

	TUint channelSessionCookie;

	TInt r = iDmaSession.ChannelOpen(iChannelCookie, channelSessionCookie);

	TEST_ASSERT(r == KErrNone);

	TDmacTestCaps channelCaps;

	r = iDmaSession.ChannelCaps(channelSessionCookie, channelCaps);

	TEST_ASSERT(r == KErrNone);

	r = iDmaSession.ChannelClose(channelSessionCookie);

	TEST_ASSERT(r == KErrNone);

	return channelCaps.iPILVersion >= 2;

	}

TBool CMultiVersionTest::Result()

	{

	TBool v1Result = iDecoratedTest->Result();

	if(gVerboseOutput || !v1Result)

		RDebug::Printf("V1 API result: %s", v1Result ? "success" : "failure");

	TBool v2Result = iNewVersionTest ? iNewVersionTest->Result() : ETrue;

	if(gVerboseOutput || !v1Result)

		RDebug::Printf("V2 API result: %s", v2Result ? "success" : "failure");

	return v1Result && v2Result;

	}

CDmaBenchmark::CDmaBenchmark(const CDmaBenchmark& aOriginal)

	:CSingleTransferTest(aOriginal)

	{

	CopyL(aOriginal.iResultArray, iResultArray);

	}