diff -r c1f20ce4abcf -r 3e88ff8f41d5 kerneltest/e32test/dmav2/t_dma2.cpp
--- a/kerneltest/e32test/dmav2/t_dma2.cpp	Tue Aug 31 16:34:26 2010 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,2851 +0,0 @@
-// Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).
-// All rights reserved.
-// This component and the accompanying materials are made available
-// under the terms of "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\dmav2\t_dma2.cpp
-
-#include "d_dma2.h"
-#include "u32std.h"
-#include "t_dma2.h"
-#include "cap_reqs.h"
-
-#define __E32TEST_EXTENSION__
-#include <e32test.h>
-#include <e32debug.h>
-#include <e32svr.h>
-#include <e32def_private.h>
-
-// DMA test framework command  parameter options
-
-// SelfTest option
-_LIT(KArgSelfTest, "/SELFTEST");  
-_LIT(KArgSelfTest2, "/S");		  
-
-//Verbose option
-_LIT(KArgVerboseOutput, "/VERBOSE"); 
-_LIT(KArgVerboseOutput2, "/V");	     
-  
-//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 gHelpRequested;   // print usage 
-TBool gVerboseOutput;   // enable verbose output 
-TBool gSelfTest;        // run SelfTest 
-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
-
-/**
-This function prints out the PSL test Information
-*/
-void Print(const TDmaV2TestInfo& aInfo)
-	{
-	PRINT(aInfo.iMaxTransferSize);
-	PRINT(aInfo.iMemAlignMask);
-	PRINT(aInfo.iMemMemPslInfo);
-	PRINT(aInfo.iMaxSbChannels);
-	for(TInt i=0; i<aInfo.iMaxSbChannels; i++)
-		{
-		PRINT(aInfo.iSbChannels[i]);
-		}
-	PRINT(aInfo.iMaxDbChannels);
-	for(TInt j=0; j<aInfo.iMaxDbChannels; j++)
-		{
-		PRINT(aInfo.iDbChannels[j]);
-		}
-	PRINT(aInfo.iMaxSgChannels);
-	for(TInt k=0; k<aInfo.iMaxSgChannels; k++)
-		{
-		PRINT(aInfo.iSgChannels[k]);
-		}
-	}
-
-void CDmaTest::PrintTestInfo() const
-	{
-	TBuf<32> buf;
-	buf.AppendFormat(_L("DMA channel %d"), iChannelCookie);
-	RDebug::RawPrint(buf);
-	}
-
-//////////////////////////////////////////////////////////////////////
-// CDmaTest
-//////////////////////////////////////////////////////////////////////
-
-void CDmaTest::OpenDmaSession()
-	{
-	// Only open a new session if one
-	// was not already supplied
-	if(iDmaSession.Handle() == KNullHandle)
-		{
-		TInt r = iDmaSession.Open();
-		if(KErrNone != r)
-			{
-			RDebug::Printf("CDmaTest::OpenDmaSession = %d\n", r);
-			}
-		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);
-	TEST_ASSERT(r == KErrNone);
-
-	// open another handle to the test driver chunk
-	r = iDmaSession.OpenSharedChunk(iChunk);
-	TEST_ASSERT(r == KErrNone);
-	}
-
-void CDmaTest::CloseDmaSession()
-	{
-	iChunk.Close();
-	iDmaSession.Close();
-	}
-
-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);
-}
-//////////////////////////////////////////////////////////////////////
-// CSingleTransferTest
-//////////////////////////////////////////////////////////////////////
-void CSingleTransferTest::RunTest()
-	{
-	OpenDmaSession();
-	PreTransferSetup();
-
-	OpenChannel();
-	CreateDmaRequest();
-	Fragment();
-	Queue();
-	FreeRequest();
-	CloseChannel();
-	PostTransferCheck();
-
-	CloseDmaSession();
-	}
-
-void CSingleTransferTest::OpenChannel()
-	{
-	iActual.iChannelOpenResult =
-		iDmaSession.ChannelOpen(iChannelCookie, iChannelSessionCookie);
-	}
-
-void CSingleTransferTest::CreateDmaRequest()
-	{
-	if(iUseNewRequest)
-	{
-		if(gVerboseOutput)
-			{
-			RDebug::Printf("Calling New Request API\n");
-			}
-		iActual.iRequestResult.iCreate =
-			iDmaSession.RequestCreate(iChannelSessionCookie, iRequestSessionCookie, iMaxFragmentSize);
-		}
-	else
-		{
-		if(gVerboseOutput)
-			{
-			RDebug::Printf("Calling Old Request API\n");
-			}
-		iActual.iRequestResult.iCreate =
-			iDmaSession.RequestCreateOld(iChannelSessionCookie, iRequestSessionCookie, iMaxFragmentSize);
-		}
-	}
-
-void CSingleTransferTest::Fragment()
-	{
-	if(iActual.iRequestResult.iCreate != KErrNone)
-		return;
-
-	if(iUseNewFragment)
-		{
-		if(gVerboseOutput)
-			{
-			RDebug::Printf("Calling New Fragment API\n");
-			}
-		iActual.iRequestResult.iFragmentationResult =
-			iDmaSession.FragmentRequest(iRequestSessionCookie, iTransferArgs);
-		}
-	else
-		{
-		if(gVerboseOutput)
-			{
-			RDebug::Printf("Calling Old Fragment API\n");
-			}
-		iActual.iRequestResult.iFragmentationResult =
-			iDmaSession.FragmentRequestOld(iRequestSessionCookie, iTransferArgs);
-		}
-
-	const TInt fragmentCount = iDmaSession.RequestFragmentCount(iRequestSessionCookie);
-
-	// Record the fragment count if a non-zero value was expected,
-	// or if it was an error value
-	if(iExpected.iRequestResult.iFragmentCount != 0 || fragmentCount < 0)
-		iActual.iRequestResult.iFragmentCount = fragmentCount;
-	}
-
-void CSingleTransferTest::Queue()
-	{
-	if(iActual.iRequestResult.iFragmentationResult == KErrNone)
-		{
-		iActual.iRequestResult.iQueueResult = iDmaSession.QueueRequest(iRequestSessionCookie, &iActual.iCallbackRecord);
-		}
-	}
-
-void CSingleTransferTest::PostTransferCheck()
-	{
-	if(iPostTransferCheck)
-		iActual.iPostTransferCheck = DoPostTransferCheck();
-	}
-
-TInt CSingleTransferTest::DoPostTransferCheck()
-	{
-	return iPostTransferCheck->Check(*this);
-	}
-
-void CSingleTransferTest::FreeRequest()
-	{
-	if(iActual.iRequestResult.iCreate == KErrNone)
-		{
-		TInt r = iDmaSession.RequestDestroy(iRequestSessionCookie);
-		TEST_ASSERT(r == KErrNone);
-		}
-	}
-
-void CSingleTransferTest::CloseChannel()
-	{
-	if(iActual.iChannelOpenResult == KErrNone)
-		{
-		TInt r = iDmaSession.ChannelClose(iChannelSessionCookie);
-		TEST_ASSERT(r == KErrNone);
-		}
-	}
-
-void CSingleTransferTest::PrintTestType() const
-	{
-	RDebug::RawPrint(_L("Single transfer"));
-	}
-
-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"));
-	}
-
-void CSingleTransferTest::PreTransferSetup()
-	{
-	if(iPreTransfer)
-		iPreTransfer->Setup(*this); //initialize test
-	}
-
-TBool CSingleTransferTest::Result()
-	{
-	const TBool result = iExpected == iActual;
-	if(!result)
-		{
-		RDebug::Printf("TResultSets do not match");
-		}
-	if(!result || gVerboseOutput)
-		{
-		RDebug::Printf("\nExpected error codes:");
-		iExpected.Print();
-		RDebug::Printf("Expected callback record:");
-		iExpected.iCallbackRecord.Print();
-
-		RDebug::Printf("\nActual error codes:");
-		iActual.Print();
-		RDebug::Printf("Actual callback record:");
-		iActual.iCallbackRecord.Print();
-		}
-	return result;
-	}
-
-//////////////////////////////////////////////////////////////////////
-// 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::CDmaBenchmark(const TDesC& aName, TInt aIterations, const TResultSet& aExpectedResults, const TDmaTransferArgs& aTransferArgs, TUint aMaxFragmentSize)
-	:CSingleTransferTest(aName, aIterations, aTransferArgs, aExpectedResults, aMaxFragmentSize, NULL, NULL)
-	{
-	UseNewDmaApi(EFalse);
-	}
-
-CDmaBenchmark::CDmaBenchmark(const CDmaBenchmark& aOriginal)
-	:CSingleTransferTest(aOriginal)
-	{
-	CopyL(aOriginal.iResultArray, iResultArray);
-	}
-
-CDmaBenchmark::~CDmaBenchmark()
-	{
-	iResultArray.Close();
-	}
-
-TUint64 CDmaBenchmark::MeanResult()
-	{
-	if(gVerboseOutput)
-		RDebug::Printf("CDmaBenchmark::MeanResult\n");
-
-	const TInt count = iResultArray.Count();
-
-	TEST_ASSERT(count > 0);
-	TEST_ASSERT(count == iIterations);
-
-	TUint64 sum = 0;
-
-	for(TInt i = 0; i < count; i++)
-		{
-		const TUint64 value = iResultArray[i];
-		if(gVerboseOutput)
-			RDebug::Printf("iResultArray[%d]: %lu", i, value);
-
-		sum += value;
-		}
-
-	return sum / count;
-	}
-
-TBool CDmaBenchmark::Result()
-	{
-	const TBool result = CSingleTransferTest::Result();
-	if(result)
-		{
-		RDebug::Printf("  Mean time: %lu us", MeanResult());
-		}
-
-	return result;
-	}
-
-//////////////////////////////////////////////////////////////////////
-// CDmaBmFragmentation
-//////////////////////////////////////////////////////////////////////
-CDmaBmFragmentation::CDmaBmFragmentation(const TDesC& aName, TInt aIterations, const TDmaTransferArgs& aTransferArgs, TUint aMaxFragmentSize)
-	:CDmaBenchmark(aName, aIterations, ExpectedResults, aTransferArgs, aMaxFragmentSize)
-	{}
-
-const TResultSet CDmaBmFragmentation::ExpectedResults(KErrNone,
-		TRequestResults(KErrNone, 0, KErrNone, KErrUnknown),
-		KErrUnknown,
-		TCallbackRecord::Empty()
-		);
-
-void CDmaBmFragmentation::Fragment()
-	{
-	TUint64 time;
-	iActual.iRequestResult.iFragmentationResult =
-		iDmaSession.FragmentRequestOld(iRequestSessionCookie, iTransferArgs, &time);
-	iResultArray.Append(time);
-	}
-
-void CDmaBmFragmentation::PrintTestType() const
-	{
-	RDebug::RawPrint(_L("Fragmentation Benchmark"));
-	}
-
-void CDmaBmFragmentation::RunTest()
-	{
-	OpenDmaSession();
-
-	OpenChannel();
-	CreateDmaRequest();
-	Fragment();
-	FreeRequest();
-	CloseChannel();
-	CloseDmaSession();
-	}
-
-//////////////////////////////////////////////////////////////////////
-//	CPauseResumeTest
-//
-//	-Time how long a given transfer takes
-//	-Pause the channel
-//	-repeat the transfer (queued asynchronously)
-//	-wait for some time (say, 3 times the time measured)
-//	-read the value of the TRequestStatus object, to check it is still pending
-//	-resume the channel
-//	-Wait on the request
-//	-Confirm that the request completed
-//////////////////////////////////////////////////////////////////////
-CPauseResumeTest::~CPauseResumeTest()
-	{
-	}
-
-void CPauseResumeTest::RunTest()
-	{
-	OpenDmaSession();
-
-	//Open a single DMA channel for a transfer
-	OpenChannel();
-
-	RDebug::Printf("Resume unpaused idle channel");
-	TInt r = iDmaSession.ChannelResume(iChannelSessionCookie);
-	TEST_ASSERT(KErrCompletion == r);
-
-	RDebug::Printf("Pause idle channel");
-	r = iDmaSession.ChannelPause(iChannelSessionCookie);
-	TEST_ASSERT(KErrNone == r);
-
-	RDebug::Printf("Pause paused idle Channel");
-	r = iDmaSession.ChannelPause(iChannelSessionCookie);
-	TEST_ASSERT(KErrCompletion == r);
-
-	RDebug::Printf("Resume paused idle channel");
-	r = iDmaSession.ChannelResume(iChannelSessionCookie);
-	TEST_ASSERT(KErrNone == r);
-
-	//Setup a DMA request and Fragment the request.
-	CreateDmaRequest();
-	Fragment();
-
-	//Queue the DMA request and time how long a transfer takes
-	TUint64 queueTime;
-	DoCalibrationTransfer(queueTime);
-
-	RDebug::Printf("Calibration transfer completed in %Lu us",queueTime);
-	TUint32 waitQueueReqTime = I64LOW(queueTime*3); //3 times the time measured in DoCalibrationTransfer
-	TEST_ASSERT(I64HIGH(queueTime*3) == 0); // If transfer takes over an hour, something has gone wrong anyway
-
-	// Initialise buffers, after calibration transfer
-	PreTransferSetup();
-
-	RDebug::Printf("Resume unpaused channel");
-	r = iDmaSession.ChannelResume(iChannelSessionCookie);
-	TEST_ASSERT(KErrCompletion == r);
-
-	//Pause DMA Transfer
-	RDebug::Printf("Pausing DMA Channel");
-	r = iDmaSession.ChannelPause(iChannelSessionCookie);
-	TEST_ASSERT(KErrNone == r);
-
-	RDebug::Printf("Pause paused Channel");
-	r = iDmaSession.ChannelPause(iChannelSessionCookie);
-	TEST_ASSERT(KErrCompletion == r);
-
-	//Repeat the transfer (queued asynchronously)
-	TRequestStatus queueRequestStatus;
-	iActual.iRequestResult.iQueueResult = QueueAsyncRequest(queueRequestStatus,queueTime);
-	RDebug::Printf("Queue a DMA Request and wait for %u us ", waitQueueReqTime);
-
-	User::After(waitQueueReqTime);
-	RDebug::Printf("Finished waiting");
-	TEST_ASSERT(queueRequestStatus.Int() == KRequestPending);
-
-	TBool queueEmpty = ETrue;
-	r = iDmaSession.ChannelIsQueueEmpty(iChannelSessionCookie,queueEmpty);
-	TEST_ASSERT(r == KErrNone);
-	TEST_ASSERT(!queueEmpty);
-
-	//Resume DMA channel
-	RDebug::Printf("Resuming paused DMA Channel");
-	r = iDmaSession.ChannelResume(iChannelSessionCookie);
-	TEST_ASSERT(KErrNone == r);
-
-	//Wait for transfer to complete
-	User::WaitForRequest(queueRequestStatus);
-	if (queueRequestStatus.Int() == KErrNone)
-		{
-		RDebug::Printf("DMA QueueAsyncRequest completed");
-		}
-
-	FreeRequest();
-	CloseChannel();
-
-	PostTransferCheck();
-	CloseDmaSession();
-	}
-
-/**
-Time how long transfer takes, with no pausing
-*/
-void CPauseResumeTest::DoCalibrationTransfer(TUint64 &atime)
-	{
-	//Queue the DMA request.
-	TCallbackRecord pCallbackRecord;
-	TInt r = iDmaSession.QueueRequest(iRequestSessionCookie,&pCallbackRecord,&atime);
-	TEST_ASSERT(r == KErrNone);
-	}
-
-TInt CPauseResumeTest::QueueAsyncRequest(TRequestStatus &aRequestState, TUint64 &atime)
-	{
-	return iDmaSession.QueueRequest(iRequestSessionCookie,aRequestState, &iActual.iCallbackRecord, &atime);
-	}
-
-void CPauseResumeTest::PrintTestType() const
-	{
-	RDebug::RawPrint(_L("Pause and Resume API Test"));
-	}
-
-//////////////////////////////////////////////////////////////////////
-//	CPauseResumeNegTest
-//
-//	-Open DMA Channel
-//	-Pause and Resume DMA channel
-//	-Check that KErrNotSupported is returned
-//	-Close DMA Channel
-//////////////////////////////////////////////////////////////////////
-CPauseResumeNegTest::~CPauseResumeNegTest()
-	{
-	}
-
-void CPauseResumeNegTest::RunTest()
-	{
-	OpenDmaSession();
-
-	//Open a single DMA channel for a transfer
-	OpenChannel();
-
-	RDebug::Printf("Resume unpaused idle channel");
-	TInt r = iDmaSession.ChannelResume(iChannelSessionCookie);
-	TEST_ASSERT(KErrNotSupported == r);
-
-	RDebug::Printf("Pause idle channel");
-	r = iDmaSession.ChannelPause(iChannelSessionCookie);
-	TEST_ASSERT(KErrNotSupported == r);
-
-	RDebug::Printf("Pause paused idle Channel");
-	r = iDmaSession.ChannelPause(iChannelSessionCookie);
-	TEST_ASSERT(KErrNotSupported == r);
-
-	RDebug::Printf("Resume paused idle channel");
-	r = iDmaSession.ChannelResume(iChannelSessionCookie);
-	TEST_ASSERT(KErrNotSupported == r);
-
-	CloseChannel();
-	CloseDmaSession();
-	}
-
-void CPauseResumeNegTest::PrintTestType() const
-	{
-	RDebug::RawPrint(_L("Pause and Resume API Test - Negative Test"));
-	}
-
-//////////////////////////////////////////////////////////////////////
-//	CLinkChannelTest
-//
-//	-Open DMA Channel
-//	-Link and Unlink DMA channel
-//	-Check that KErrNotSupported is returned
-//	-Close DMA Channel
-//
-//////////////////////////////////////////////////////////////////////
-CLinkChannelTest::~CLinkChannelTest()
-	{
-	}
-
-void CLinkChannelTest::RunTest()
-	{
-	OpenDmaSession();
-
-	//Open a single DMA channel for a transfer
-	OpenChannel();
-
-	RDebug::Printf("Linking DMA channels");
-	TInt r = iDmaSession.ChannelLinking(iChannelSessionCookie);
-	TEST_ASSERT(KErrNotSupported == r);
-
-	RDebug::Printf("Unlinking DMA channels");
-	r = iDmaSession.ChannelUnLinking(iChannelSessionCookie);
-	TEST_ASSERT(KErrNotSupported == r);
-
-	CloseChannel();
-	CloseDmaSession();
-	}
-
-void CLinkChannelTest::PrintTestType() const
-	{
-	RDebug::RawPrint(_L("Channel Linking API Test - Negative Test"));
-	}
-
-//////////////////////////////////////////////////////////////////////
-//	CElementCountingTest
-//
-//	-Open DMA Channel
-//	-Create Request
-//	-Fragment and Make calls to Element Counting APIs
-//  -Check that TotalNumDstElementsTransferred() and TotalNumSrcElementsTransferred()
-//	 return non zero values
-//  -Check that KErrNone(from test driver) returned for other API calls
-//	-Queue Request 
-//	-Close DMA Channel
-//////////////////////////////////////////////////////////////////////
-CElementCountingTest::~CElementCountingTest()
-	{
-	}
-
-void CElementCountingTest::RunTest()
-	{
-	OpenDmaSession();
-	PreTransferSetup();
-
-	//Open a single DMA channel for a transfer
-	OpenChannel();
-	
-	//Setup a DMA request and Fragment the request.
-	RDebug::Printf("Create and Fragment DMA Request");
-	CreateDmaRequest();
-	Fragment();
-
-	//Enable src/dst counting
-	RDebug::Printf("Enable DstElementCounting");
-	TInt r = iDmaSession.RequestEnableDstElementCounting(iRequestSessionCookie);
-	TEST_ASSERT(KErrNone == r);
-
-	RDebug::Printf("Enable SrcElementCounting");
-	r = iDmaSession.RequestEnableSrcElementCounting(iRequestSessionCookie);
-	TEST_ASSERT(KErrNone == r);
-
-	//Queue request
-	RDebug::Printf("Queue DMA Request");
-	Queue();
-
-	//Disable src/dst counting
-	RDebug::Printf("Disable DstElementCounting");
-	r = iDmaSession.RequestDisableDstElementCounting(iRequestSessionCookie);
-	TEST_ASSERT(KErrNone == r);
-
-	RDebug::Printf("Disable SrcElementCounting");
-	r = iDmaSession.RequestDisableSrcElementCounting(iRequestSessionCookie);
-	TEST_ASSERT(KErrNone == r);
-
-	//check total src/dst elements transferred
-	RDebug::Printf("Get Total Number of DstElementsTransferred");
-	r = iDmaSession.RequestTotalNumDstElementsTransferred(iRequestSessionCookie);
-	TEST_ASSERT(r >= 0);
-
-	RDebug::Printf("Get Total Number of SrcElementsTransferred");
-	r = iDmaSession.RequestTotalNumSrcElementsTransferred(iRequestSessionCookie);
-	TEST_ASSERT(r >= 0);
-
-	FreeRequest();
-	CloseChannel();
-
-	PostTransferCheck();
-	CloseDmaSession();
-	}
-
-void CElementCountingTest::PrintTestType() const
-	{
-	RDebug::RawPrint(_L("Element Counting Tests"));
-	}
-
-//////////////////////////////////////////////////////////////////////
-// COpenCloseTest
-//////////////////////////////////////////////////////////////////////
-COpenCloseTest::~COpenCloseTest()
-	{
-	}
-
-TBool COpenCloseTest::DoRunClose()
-	{
-	// For storing cookie during neagtive test i,e open channel twice
-	TUint testChannelSessionCookie = 0; 
-
-	// Open a single DMA channel
-	TInt r = iDmaSession.ChannelOpen(iChannelCookie, iChannelSessionCookie);
-	if (r == KErrNone)//Check that DMA channel opened with no errors
-		{
-		RDebug::Printf("DMA channel opened");					
-		}
-	else
-		{
-		RDebug::Printf("Open DMA channel failed");			
-		return EFalse;
-		}
-
-	// Open DMA channel again and check that opening DMA channel again fails		
-	r = iDmaSession.ChannelOpen(iChannelCookie, testChannelSessionCookie);
-	if (r == KErrInUse)
-		{
-		RDebug::Printf("Opening DMA channel again fails as expected");	
-		}
-	else
-		{
-		RDebug::Printf("Open DMA channel again failed");
-		return EFalse;
-		}
-
-	// Close the DMA channel and check that DMA channel closes with no errors
-	r =iDmaSession.ChannelClose(iChannelSessionCookie);	 
-	if (r == KErrNone) 
-		{
-		RDebug::Printf("DMA channel closes with no errors");				
-		}
-	else
-		{
-		RDebug::Printf("Close the DMA channel failed");
-		return EFalse;
-		}
-	
-	// Verify that the DMA channel was actually closed by opening DMA channel
-	r = iDmaSession.ChannelOpen(iChannelCookie, iChannelSessionCookie);
-	if (r == KErrNone)
-		{
-		RDebug::Printf("DMA channel opened after a previous close operation");
-		return ETrue;
-		}
-	else
-		{
-		RDebug::Printf("Open DMA channel to verify that the DMA channel closed failed");
-		return EFalse;
-		}	
-	}
-
-TBool COpenCloseTest::DoRunOpen()
-	{
-	// Open a single DMA channel
-	TInt r = iDmaSession.ChannelOpen(iChannelCookie, iChannelSessionCookie);
-	if (r == KErrNone)//Check that DMA channel opened with no errors
-		{			
-		RDebug::Printf("DoRunOpen:DMA channel opened");			
-		}
-	else
-		{
-		RDebug::Printf("DoRunOpenDMA channel failed to open");				
-		return EFalse;
-		}	
-
-	// Verify that channel is really open by closing DMA channel
-	// and checking that DMA channel closes with no errors
-	r = iDmaSession.ChannelClose(iChannelSessionCookie);
-	if (r == KErrNone)
-		{
-		RDebug::Printf("DoRunOpen:DMA channel closes with no errors");			
-		return ETrue;
-		}
-	else
-		{
-		RDebug::Printf("DoRunOpen:DMA channel failed to close");		
-		return EFalse;
-		}
-	}
-
-TBool COpenCloseTest::DoRunOpenExposed()
-	{
-	SCreateInfoTest TOpenInfo;
-	TOpenInfo.iCookie =iChannelCookie;
-	TOpenInfo.iDfcPriority = 3;
-	
-	const TInt desCount[3] = {0,1,128}; 
-	const TBool dynChannel[3] =	{EFalse,EFalse,ETrue};  
-	const TInt expectedResults[3] = {KErrArgument,KErrNone,KErrInUse};  
-	TInt actualResults[3] = {1, 1, 1};
-
-	for (TInt i =0; i<3; i++)
-		{	
-		TOpenInfo.iDesCount = desCount[i];
-		TOpenInfo.iDynChannel = dynChannel[i];		
-
-		// Open a single DMA channel
-		RDebug::Printf("DoRunOpenExposed:Trying to open DMA channel using iDesCount(%d) and iDynChannel(%d)  ", TOpenInfo.iDesCount,TOpenInfo.iDynChannel);
-		actualResults[i] = iDmaSession.ChannelOpen(iChannelSessionCookie, TOpenInfo);
-		if (actualResults[i] == KErrNone)// Verify that channel is really open by closing DMA channel	
-			{
-			TInt err = iDmaSession.ChannelClose(iChannelSessionCookie);
-			TEST_ASSERT(err == KErrNone)//Check that DMA channel closed with no errors
-			}
-		}
-
-	// This case should fail if idesCount  =  0.
-	// PIL has been changed to return KErrArgument instead of using an assertion check
-	if (expectedResults[0] == actualResults[0])
-		{
-		RDebug::Printf("DoRunOpenExposed:DMA channel failed to open as expected as for iDesCount = 0 ");			
-		}
-	else
-		{
-		RDebug::Printf("DoRunOpenExposed:Error code returned (%d), expected KErrArgument as iDesCount= 0) ", actualResults[0]);	
-		return EFalse;
-		}
-
-	// For this case( idesCount  =  1), DMA channel should open with no issues	
-	if (expectedResults[1] == actualResults[1])
-		{		
-		RDebug::Printf("DoRunOpenExposed:DMA channel closes with no errors as expected for iDesCount = 1 ");
-		}
-	else
-		{
-		RDebug::Printf("DoRunOpenExposed:Failed to open DMA channel with error code (%d)", actualResults[1]);	
-		return EFalse;
-		}
-
-	// For this case(dynaChannel=ETrue), DMA channel now returns KErrInUse. dynaChannel is not supported in the PSL.
-	// PSL now returns a NULL pointer when dynaChannel is requested. The PIL interprets a NULL 
-	// pointer being returned from opening a DMA channel as a channel in use. Hence, KErrInUse is returned.
-	if (expectedResults[2] == actualResults[2])
-		{
-		RDebug::Printf("DoRunOpenExposed:DMA channel failed to open as expected as dynamic channel is not supported");		
-		}
-	else
-		{
-		RDebug::Printf("DoRunOpenExposed:Error code returned (%d), expected KErrInUse as as dynamic channel is not supported", actualResults[2]);			
-		return EFalse;
-		}
-
-	return ETrue;
-	}
-
-void COpenCloseTest::RunTest()
-	{
-	OpenDmaSession(); 
-
-	if (iRunOpen) 
-	{	// Run Open() API test
-		iOpenCloseResult = DoRunOpenExposed();
-		if(iOpenCloseResult)
-			iOpenCloseResult = DoRunOpen();
-	}
-	else
-	{
-		// Run Close() API test	
-		iOpenCloseResult = DoRunClose();
-	}
-
-	CloseDmaSession();
-	}
-
-void COpenCloseTest::PrintTestType() const
-	{
-	RDebug::RawPrint(_L("Close/Open API Test"));
-
-	}
-
-TBool COpenCloseTest::Result()
-	{
-	if(gVerboseOutput)
-		{
-		RDebug::Printf("Results for Close/Open API Test");
-		}
-
-	if(!iOpenCloseResult)
-		{
-		RDebug::Printf("Open/Close test sequence failed"); 
-		}
-			
-	return iOpenCloseResult;
-	}
-//////////////////////////////////////////////////////////////////////
-// CDmaBmTransfer
-//////////////////////////////////////////////////////////////////////
-CDmaBmTransfer::CDmaBmTransfer(const TDesC& aName, TInt aIterations, const TDmaTransferArgs& aTransferArgs, TUint aMaxFragmentSize)
-	:CDmaBenchmark(aName, aIterations,
-		TResultSet(KErrNone, TRequestResults(),	KErrUnknown, TCallbackRecord(TCallbackRecord::EThread,1)),
-		aTransferArgs, aMaxFragmentSize)
-	{}
-
-void CDmaBmTransfer::PrintTestType() const
-	{
-	RDebug::RawPrint(_L("Transfer Benchmark"));
-	}
-
-void CDmaBmTransfer::RunTest()
-	{
-	OpenDmaSession();
-
-	OpenChannel();
-	CreateDmaRequest();
-	Fragment();
-	Queue();
-	FreeRequest();
-	CloseChannel();
-
-	CloseDmaSession();
-	}
-
-void CDmaBmTransfer::Queue()
-	{
-	if(iActual.iRequestResult.iFragmentationResult == KErrNone)
-		{
-		TUint64 time;
-		iActual.iRequestResult.iQueueResult = iDmaSession.QueueRequest(iRequestSessionCookie, &iActual.iCallbackRecord, &time);
-		iResultArray.Append(time);
-		}
-	}
-
-/*
-1.	Open a DMA channel for a transfer.
-2.	Queue multiple request on the DMA channel.
-3.	Call CancelAll () on the DMA channel.
-4.	Verify that all transfers have been cancelled.
-5.	Open a DMA channel for a transfer. This channel should support pause and resume.
-6.	Call Pause () on the channel.
-7.	Queue multiple request on the DMA channel.
-8.	Call CancelAll () on the channel.
-9.	Verify that all transfers have been cancelled.
-
-   Note: This check does not add results to TResultSet like some
-   other tests as its operation is different. The test checks for 
-   the the cancelllation of all transfers queued on a channel by
-   calling iDmaSession.ChannelIsQueueEmpty(); 
-*/
-
-//////////////////////////////////////////////////////////////////////
-// CCancelAllTest
-//////////////////////////////////////////////////////////////////////
-
-
-CCancelAllTest::CCancelAllTest(const TDesC& aName, TInt aIterations,
-		const TDmaTransferArgs* aTransferArgs, const TResultSet* aResultSets,
-		TInt aCount)
-	:CMultiTransferTest(aName, aIterations, aTransferArgs, aResultSets, aCount)
-	{}
-
-void CCancelAllTest::RunTest()
-	{
-	OpenDmaSession();
-	PreTransferSetup();
-
-	// Open a DMA channel for a transfer.This channel should support pause and resume.
-	OpenChannel();
-
-	//Call Pause () on the channel
-	RDebug::Printf("Pausing DMA Channel");
-	ChannelPause(iChannelSessionCookie);
-	
-	// Queue multiple request on the DMA channel.
-	CreateDmaRequests();
-	Fragment();
-
-	QueueRequestsAsync();
-
-	// Call CancelAll () on the DMA channel and Verify that all transfers have been cancelled.
-	TInt r = CancelAllRequests();
-	TEST_ASSERT(r == KErrNone);
-
-	//Call Resume () on the channel.
-	RDebug::Printf("Cancel should clear Pause state: resuming channel should fail");
-	ChannelResume(iChannelSessionCookie);		
-	//TEST_ASSERT(r == KErrCompletion);
-
-	r = DoPostTransferCheck();
-	TEST_ASSERT(r == KErrNone);
-	//Destroy request
-    for(TInt i=0; i<2; i++)
-		{
-		r = iDmaSession.RequestDestroy(iRequestCookies[i]);
-		TEST_ASSERT(r == KErrNone);
-		}
-
-	//Close DMA channel
-	CloseChannel();
-
-	CloseDmaSession();
-	}
-
-TInt CCancelAllTest::CancelAllRequests()
-	{
-	if(gVerboseOutput)
-		{
-		RDebug::Printf("CCancelAllTest::CancelAllRequests()");
-		}
-	TInt r = KErrGeneral;
-	r  = iDmaSession.ChannelCancelAll(iChannelSessionCookie);
-	if (r != KErrNone)
-		return r;
-
-	TBool queueEmpty;
-	r = iDmaSession.ChannelIsQueueEmpty(iChannelSessionCookie,queueEmpty);
-	if (r != KErrNone)
-		return r;
-
-	if(!queueEmpty)
-		return KErrGeneral;
-
-	if(gVerboseOutput)
-		{
-		RDebug::Printf("Both current and pending requests cancelled");
-		}
-	return KErrNone;
-	}
-
-void CCancelAllTest::PrintTestType() const
-	{
-	RDebug::RawPrint(_L("CCancelAllTest"));
-	}
-
-void CCancelAllTest::QueueRequestsAsync()
-	{
-	if(iPauseWhileQueuing)
-		{
-		TInt r = iDmaSession.ChannelPause(iChannelSessionCookie);
-		TEST_ASSERT(r == KErrNone);
-		}
-
-	// Queue all the DMA requests asynchronously
-	TEST_ASSERT(iActualResults.Count() == iTransferArgsCount);
-	for(TInt i=0; i<iTransferArgsCount; i++)
-		{
-		TResultSet& resultSet = iActualResults[i];
-		if(resultSet.iRequestResult.iFragmentationResult != KErrNone)
-			continue;
-
-		TInt r = iDmaSession.QueueRequest(iRequestCookies[i], iDummyRequestStatus, &resultSet.iCallbackRecord, NULL);
-		resultSet.iRequestResult.iQueueResult = r;
-		}
-
-	if(iPauseWhileQueuing)
-		{
-		TInt r = iDmaSession.ChannelResume(iChannelSessionCookie);
-		TEST_ASSERT(r == KErrNone);
-		}
-	}
-
-//////////////////////////////////////////////////////////////////////
-// CIsQueueEmptyTest
-//////////////////////////////////////////////////////////////////////
-CIsQueueEmptyTest::CIsQueueEmptyTest(const TDesC& aName, TInt aIterations, const TDmaTransferArgs* aTransferArgs,
-		const TResultSet* aResultSets, TInt aCount)
-	:CMultiTransferTest(aName, aIterations, aTransferArgs, aResultSets, aCount)
-	{}
-
-CIsQueueEmptyTest::CIsQueueEmptyTest(const CIsQueueEmptyTest& aOther)
-	:CMultiTransferTest(aOther)
-	{}
-
-CIsQueueEmptyTest::~CIsQueueEmptyTest()
-	{
-	}
-
-void CIsQueueEmptyTest::RunTest()
-	{
-	OpenDmaSession();
-	PreTransferSetup();
-	
-	OpenChannel();
-
-	CreateDmaRequests();
-	Fragment();
-	QueueRequests();
-
-	TInt r = DoPostTransferCheck();
-	TEST_ASSERT(r == KErrNone);
-
-	CloseDmaSession();
-	}
-
-void CIsQueueEmptyTest::DoIsQueueEmpty()
-	{
-	TBool queueEmpty;
-	TInt r = iDmaSession.ChannelIsQueueEmpty(iChannelSessionCookie,queueEmpty);
-	TEST_ASSERT(r == KErrNone);
-
-	if(queueEmpty)
-		{
-		RDebug::Printf("Verified that calling IsQueueEmpty() returns ETrue before calling Queue()");
-		}
-	else
-		{
-		RDebug::Printf("IsQueueEmpty() fails to return ETrue before calling Queue()");
-		TEST_ASSERT(queueEmpty);	
-		}
-	}
-
-void CIsQueueEmptyTest::DoQueueNotEmpty()
-	{
-	TBool queueEmpty;
-	TInt r = iDmaSession.ChannelIsQueueEmpty(iChannelSessionCookie,queueEmpty);
-	TEST_ASSERT(r == KErrNone);
-
-	if (!queueEmpty)
-		{
-		RDebug::Printf("Verified that calling IsQueueEmpty() returns EFalse after calling Queue()");
-		}
-	else
-		{
-		RDebug::Printf("IsQueueEmpty() fails to return EFalse after calling Queue()");
-		TEST_ASSERT(!queueEmpty);
-		}
-	}
-
-void CIsQueueEmptyTest::PrintTestType() const
-	{
-	RDebug::RawPrint(_L("IsQueue Empty Test using Multi Transfer"));
-	}
-
-void CIsQueueEmptyTest::QueueRequests()
-	{
-	// Queue all the DMA requests asynchronously
-	TInt i;
-	RArray<TRequestStatus> requestStates;
-	
-	ChannelPause(iChannelSessionCookie);
-	DoIsQueueEmpty();
-
-	TEST_ASSERT(iActualResults.Count() == iTransferArgsCount);
-	for(i=0; i<iTransferArgsCount; i++)
-		{
-		TResultSet& resultSet = iActualResults[i];
-		if(resultSet.iRequestResult.iFragmentationResult != KErrNone)
-			continue;
-
-		TInt r = requestStates.Append(TRequestStatus());
-		TEST_ASSERT(r == KErrNone);
-
-		r = iDmaSession.QueueRequest(iRequestCookies[i], requestStates[i], &resultSet.iCallbackRecord, NULL);
-		resultSet.iRequestResult.iQueueResult = r;
-
-		DoQueueNotEmpty();
-		}
-	
-	ChannelResume(iChannelSessionCookie);
-
-	// wait for all transfers to complete
-	const TInt count = requestStates.Count();
-
-	for(i=0; i<count; i++)
-		{
-		User::WaitForRequest(requestStates[i]);
-		}
-
-	requestStates.Close();
-	}
-
-//////////////////////////////////////////////////////////////////////
-// CMultiTransferTest
-//////////////////////////////////////////////////////////////////////
-CMultiTransferTest::CMultiTransferTest(const TDesC& aName, TInt aIterations, const TDmaTransferArgs* aTransferArgs,
-		const TResultSet* aResultSets, TInt aCount)
-	: CDmaTest(aName, aIterations, NULL, NULL), iTransferArgs(aTransferArgs), iTransferArgsCount(aCount), iNewDmaApi(ETrue),
-	iChannelSessionCookie(0), iExpectedArray(aResultSets), iPauseWhileQueuing(EFalse)
-	{}
-
-CMultiTransferTest::CMultiTransferTest(const CMultiTransferTest& aOther)
-	: CDmaTest(aOther), iTransferArgs(aOther.iTransferArgs), iTransferArgsCount(aOther.iTransferArgsCount),
-	iNewDmaApi(aOther.iNewDmaApi),
-	iExpectedArray(aOther.iExpectedArray), iPauseWhileQueuing(aOther.iPauseWhileQueuing)
-	{
-	CopyL(aOther.iRequestCookies, iRequestCookies);
-	}
-
-CMultiTransferTest::~CMultiTransferTest()
-	{
-	iRequestCookies.Close();
-	iActualResults.Close();
-	}
-
-TBool CMultiTransferTest::Result()
-	{
-	if(gVerboseOutput)
-		{
-		RDebug::Printf("Results for %d transfers:", iTransferArgsCount);
-		}
-
-	TBool result = EFalse;
-	for(TInt i=0; i<iTransferArgsCount; i++)
-		{
-		result = Result(i);
-		if(!result)
-			break;
-		}
-	return result;
-	}
-
-TBool CMultiTransferTest::Result(TInt aTransfer)
-	{
-	const TResultSet& expected = iExpectedArray[aTransfer];
-	const TResultSet& actual = iActualResults[aTransfer];
-	const TBool result = expected == actual;
-	if(!result || gVerboseOutput)
-		{
-		RDebug::Printf("Compairing results for transfer %d", aTransfer);
-		}
-
-	if(!result)
-		{
-		RDebug::Printf("TResultSets do not match");
-		}
-	if(!result || gVerboseOutput)
-		{
-		RDebug::Printf("\nExpected error codes:");
-		expected.Print();
-		RDebug::Printf("Expected callback record:");
-		expected.iCallbackRecord.Print();
-
-		RDebug::Printf("\nActual error codes:");
-		actual.Print();
-		RDebug::Printf("Actual callback record:");
-		actual.iCallbackRecord.Print();
-		}
-	return result;
-	}
-void CMultiTransferTest::RunTest()
-	{
-	OpenDmaSession();
-
-	PreTransferSetup();
-	OpenChannel();
-
-	CreateDmaRequests();
-	Fragment();
-
-	QueueRequests();
-
-	TInt r = DoPostTransferCheck();
-	TEST_ASSERT(r == KErrNone);
-
-	CloseDmaSession();
-	}
-
-void CMultiTransferTest::PrintTestType() const
-	{
-	RDebug::RawPrint(_L("Multi Transfer"));
-	}
-
-const TDmaTransferArgs& CMultiTransferTest::TransferArgs(TInt aIndex) const
-	{
-	TEST_ASSERT(Rng(0, aIndex, iTransferArgsCount-1));
-
-	return iTransferArgs[aIndex];
-	}
-
-void CMultiTransferTest::SetPostTransferResult(TInt aIndex, TInt aErrorCode)
-	{
-	TEST_ASSERT(Rng(0, aIndex, iTransferArgsCount-1));
-
-	iActualResults[aIndex].iPostTransferCheck = aErrorCode;
-	}
-
-void CMultiTransferTest::OpenChannel()
-	{
-	if(gVerboseOutput)
-		{
-		RDebug::Printf("CMultiTransferTest::OpenChannel()");
-		}
-	TInt r = iDmaSession.ChannelOpen(iChannelCookie, iChannelSessionCookie);
-
-	TEST_ASSERT(iActualResults.Count() == iTransferArgsCount);
-	for(TInt i=0; i<iTransferArgsCount; i++)
-		{
-		// In a multi transfer test a series of requests are created and queued.
-		// They all use the same channel, is opened here at the beginning of the test
-		//
-		// Each transfer has a TResultSet which holds a result for the channel opening,
-		// which we store here. Although in this case it is redundant,
-		// in future it might be that different transfers open
-		// different channels.
-		iActualResults[i].iChannelOpenResult = r;
-		}
-	}
-
-TInt CMultiTransferTest::CloseChannel()
-	{
-	return iDmaSession.ChannelClose(iChannelSessionCookie);
-	}
-
-void CMultiTransferTest::CreateDmaRequests()
-	{
-	if(gVerboseOutput)
-		{
-		RDebug::Printf("CMultiTransferTest::CreateDmaRequests() %d", iTransferArgsCount);
-		}
-	TEST_ASSERT(iActualResults.Count() == iTransferArgsCount);
-	//create a DMA request for each transfer arg struct
-	for(TInt i=0; i<iTransferArgsCount; i++)
-		{
-		if(iActualResults[i].iChannelOpenResult != KErrNone)
-			continue;
-
-		TUint cookie = 0;
-		TInt r = KErrGeneral;
-
-		if(iNewDmaApi)
-			{
-			r = iDmaSession.RequestCreate(iChannelSessionCookie, cookie);
-			}
-		else
-			{
-			r = iDmaSession.RequestCreateOld(iChannelSessionCookie, cookie);
-			}
-		iActualResults[i].iRequestResult.iCreate = r;
-
-		if(r == KErrNone)
-			{
-			r = iRequestCookies.Append(cookie);
-			TEST_ASSERT(r == KErrNone);
-			}
-		}
-	}
-
-void CMultiTransferTest::Fragment()
-	{
-	if(gVerboseOutput)
-		{
-		RDebug::Printf("CMultiTransferTest::Fragment() %d", iTransferArgsCount);
-		}
-	TEST_ASSERT(iActualResults.Count() == iTransferArgsCount);
-	// Fragment each dma request
-	for(TInt i=0; i<iTransferArgsCount; i++)
-		{
-		TRequestResults& result = iActualResults[i].iRequestResult;
-		if(result.iCreate != KErrNone)
-			continue;
-
-		TInt r = KErrGeneral;
-		if(iNewDmaApi)
-			r = iDmaSession.FragmentRequest(iRequestCookies[i], iTransferArgs[i]);
-		else
-			r = iDmaSession.FragmentRequestOld(iRequestCookies[i], iTransferArgs[i]);
-
-		result.iFragmentationResult = r;
-		}
-	}
-
-void CMultiTransferTest::QueueRequests()
-	{
-	if(iPauseWhileQueuing)
-		{
-		TInt r = iDmaSession.ChannelPause(iChannelSessionCookie);
-		TEST_ASSERT(r == KErrNone);
-		}
-
-	// Queue all the DMA requests asynchronously
-	TInt i;
-	RArray<TRequestStatus> requestStates;
-
-	TEST_ASSERT(iActualResults.Count() == iTransferArgsCount);
-	for(i=0; i<iTransferArgsCount; i++)
-		{
-		TResultSet& resultSet = iActualResults[i];
-		if(resultSet.iRequestResult.iFragmentationResult != KErrNone)
-			continue;
-
-		TInt r = requestStates.Append(TRequestStatus());
-		TEST_ASSERT(r == KErrNone);
-
-		r = iDmaSession.QueueRequest(iRequestCookies[i], requestStates[i], &resultSet.iCallbackRecord, NULL);
-		resultSet.iRequestResult.iQueueResult = r;
-		}
-
-	if(iPauseWhileQueuing)
-		{
-		TInt r = iDmaSession.ChannelResume(iChannelSessionCookie);
-		TEST_ASSERT(r == KErrNone);
-		}
-
-	// wait for all transfers to complete
-	const TInt count = requestStates.Count();
-
-	for(i=0; i<count; i++)
-		{
-		User::WaitForRequest(requestStates[i]);
-		}
-
-	requestStates.Close();
-	}
-
-void CMultiTransferTest::PreTransferSetup()
-	{
-	// TODO this is the wrong place to do this!
-	for(TInt i=0; i<iTransferArgsCount; i++)
-		{
-		//pre-fill actual results with error values
-		TInt r = iActualResults.Append(TResultSet(EFalse));
-		TEST_ASSERT(r == KErrNone);
-		}
-	if(iPreTransfer)
-		iPreTransfer->Setup(*this); //initialize test
-	}
-
-TInt CMultiTransferTest::DoPostTransferCheck()
-	{
-	if(iPostTransferCheck)
-		return iPostTransferCheck->Check(*this);
-	else
-		return KErrNone;
-	}
-//////////////////////////////////////////////////////////////////////
-// CIsrRequeTest
-//////////////////////////////////////////////////////////////////////
-CIsrRequeTest::CIsrRequeTest(const TDesC& aName, TInt aIterations, const TDmaTransferArgs& aArgs,
-			TIsrRequeArgs* aRequeueArgs, TInt aCount,
-			const TResultSet& aExpected,const MPreTransfer* aPreTfer,const MPostTransferCheck* aPostTferChk, TUint aMaxFragmentSize)
-	:CSingleTransferTest(aName, aIterations, aArgs, aExpected, aMaxFragmentSize, aPostTferChk, aPreTfer), iRequeArgSet(aRequeueArgs, aCount)
-	{}
-
-void CIsrRequeTest::Queue()
-	{
-	if(iActual.iRequestResult.iFragmentationResult == KErrNone)
-		{
-		iActual.iRequestResult.iQueueResult = iDmaSession.QueueRequestWithRequeue(iRequestSessionCookie, iRequeArgSet.iRequeArgs, iRequeArgSet.iCount, &iActual.iCallbackRecord);
-		}
-	}
-
-void CIsrRequeTest::PrintTestType() const
-	{
-	RDebug::RawPrint(_L("ISR Requeue"));
-	}
-
-void CIsrRequeTest::PreTransferSetup()
-	{
-	if(iPreTransfer)
-		iPreTransfer->Setup(*this); //initialize test
-	}
-
-TInt CIsrRequeTest::DoPostTransferCheck()
-	{
-	return iPostTransferCheck->Check(*this);
-	}
-
-//////////////////////////////////////////////////////////////////////
-// TResultSet
-//////////////////////////////////////////////////////////////////////
-void TResultSet::Print() const
-	{
-	PRINT(iChannelOpenResult);
-	PRINT(iRequestResult.iCreate);
-	PRINT(iRequestResult.iFragmentCount);
-	PRINT(iRequestResult.iFragmentationResult);
-	PRINT(iRequestResult.iQueueResult);
-	PRINT(iPostTransferCheck);
-	}
-
-TBool TResultSet::operator == (const TResultSet& aOther) const
-	{
-	return (memcompare((TUint8*)this, sizeof(*this), (TUint8*)&aOther, sizeof(aOther)) == 0);
-	}
-
-//////////////////////////////////////////////////////////////////////
-// MPostTransferCheck classes
-//////////////////////////////////////////////////////////////////////
-TInt TCompareSrcDst::Check(const CSingleTransferTest& aTest) const
-	{
-	if(gVerboseOutput)
-		{
-		RDebug::Printf("Comparing CSingleTransferTest buffers");
-		}
-	return Check(aTest.TransferArgs(), aTest.Chunk().Base());
-	}
-
-// Note: this check will not deal correctly with transfers were subsequent
-// requeues overlap previous sources or destinations
-// or where the source of transfer depends on a previous transfer.
-// This is because it simply compares the source and destination
-// pairwise for each transfer
-//
-// If TPreTransferIncrBytes is used for the pre-test then the transfers
-// will be checked however.
-TInt TCompareSrcDst::Check(const CIsrRequeTest& aTest) const
-	{
-	if(gVerboseOutput)
-		{
-		RDebug::Printf("Comparing CIsrRequeTest buffers");
-		}
-	TUint8* chunkBase = aTest.Chunk().Base();
-	const TDmaTransferArgs& transferArgs = aTest.TransferArgs();
-	// check first transfer
-	TInt r = Check(transferArgs, chunkBase);
-
-	if(r != KErrNone)
-		return r;
-
-	// check re-queued transfers
-	const TIsrRequeArgsSet& requeueArgs = aTest.GetRequeueArgs();
-	return Check(requeueArgs, chunkBase, transferArgs);
-	}
-
-TInt TCompareSrcDst::Check(const TDmaTransferArgs& aTransferArgs, TUint8* aChunkBase) const
-	{	
-	const TUint32 srcOffset = aTransferArgs.iSrcConfig.iAddr;
-	const TUint32 dstOffset = aTransferArgs.iDstConfig.iAddr;
-	const TInt size = aTransferArgs.iTransferCount;
-
-	const TUint8* src = srcOffset + aChunkBase;
-	const TUint8* dst = dstOffset + aChunkBase;
-
-	if(gVerboseOutput)
-		{
-		RDebug::Printf("Comparing TDmaTransferArgs buffers src=0x%08x dst=0x%08x size=0x%08x",
-				src, dst, size);
-		}
-
-	return memcompare(src, size, dst, size);
-	}
-
-TInt TCompareSrcDst::Check(const TIsrRequeArgsSet& aRequeueArgSet, TUint8* aChunkBase, const TDmaTransferArgs& aTferArgs) const
-	{
-	TIsrRequeArgsSet argSet(aRequeueArgSet); //copy since Fixup will mutate object
-
-	argSet.Substitute(aTferArgs); // replace any default (0) values with the values in aTferArgs
-
-	argSet.Fixup((TLinAddr)aChunkBase); //convert address offsets to virtual user mode addresses
-
-	TInt r = KErrCorrupt;
-	while(!argSet.IsEmpty())
-		{
-		r = Check(argSet.GetArgs());
-		if(r != KErrNone)
-			break;
-		}
-	return r;
-	}
-
-TInt TCompareSrcDst::Check(const TIsrRequeArgs& aRequeueArgs) const
-	{
-	const TUint8* src = (TUint8*)aRequeueArgs.iSrcAddr;
-	const TUint8* dst = (TUint8*)aRequeueArgs.iDstAddr;
-	const TInt size = aRequeueArgs.iTransferCount;
-
-	if(gVerboseOutput)
-		{
-		RDebug::Printf("Comparing TIsrRequeArgs: src=0x%08x dst=0x%08x size=0x%08x",
-				src, dst, size);
-		}
-
-	return memcompare(src, size, dst, size);
-	}
-
-// Note: this check will not deal correctly with transfers were subsequent
-// requeues overlap previous sources or destinations
-// or where the source of trasnfer depends on a previous trasnfer.
-// This is because it simply compares the source and destination
-// pairwise for each transfer
-//
-// If TCompareSrcDst is used for the pre-test then the transfers
-// will be checked however.
-TInt TCompareSrcDst::Check(CMultiTransferTest& aTest) const
-	{
-	if(gVerboseOutput)
-		{
-		RDebug::Printf("Comparing CMultiTransferTest buffers");
-		}
-
-	const TInt transferCount = aTest.TransferCount();
-	TUint8* const chunkBase = aTest.Chunk().Base();
-
-	// check buffers for each transfer
-	for(TInt i=0; i<transferCount; i++)
-		{
-		TInt r = Check(aTest.TransferArgs(i), chunkBase);
-		aTest.SetPostTransferResult(i, r);
-		}
-	// CMultiTransferTest is handled differently to the others.
-	// Whereas CSingleTransferTest logs just the return value
-	// of the check, here, we write back a result for each transfer
-	// so the return value from this function is not important
-	return KErrNone;
-	}
-
-TInt TCompare2D::Check(const CSingleTransferTest& aTest) const
-	{
-	const TDmaTransferArgs& args = aTest.TransferArgs();
-	TUint8* const chunkBase = aTest.Chunk().Base();
-
-	TInt ret = KErrNone;
-
-	TTransferIter src_iter(args.iSrcConfig, chunkBase);
-	TTransferIter dst_iter(args.iDstConfig, chunkBase);
-	TTransferIter end;
-	for (; (src_iter != end) && (dst_iter !=end); ++src_iter, ++dst_iter)
-		{
-		if(*src_iter != *dst_iter)
-			{
-			ret = KErrCorrupt;
-			break;
-			}
-		}
-	return ret;
-	}
-
-TInt TCompare2D::Check(const CIsrRequeTest&) const
-	{
-	return KErrNotSupported;
-	}
-
-TInt TCompare2D::Check(CMultiTransferTest&) const
-	{
-	return KErrNotSupported;
-	}
-
-
-TInt TCheckNoTransfer::Check(const CSingleTransferTest&) const
-	{
-	return KErrNotSupported;
-	}
-
-TInt TCheckNoTransfer::Check(const CIsrRequeTest&) const
-	{
-	return KErrNotSupported;
-	}
-
-TInt TCheckNoTransfer::Check(CMultiTransferTest& aTest) const
-	{
-	if(gVerboseOutput)
-		{
-		RDebug::Printf("TCheckNoTransfer Comparing CMultiTransferTest buffers");
-		}
-
-	const TInt transferCount = aTest.TransferCount();
-	TUint8* const chunkBase = aTest.Chunk().Base();
-
-	// check buffers for each transfer
-	for(TInt i=0; i<transferCount; i++)
-		{
-		TInt r = KErrCorrupt;
-		if(IsZeroed(aTest.TransferArgs(i), chunkBase))
-			{
-			r = KErrNone;
-			}
-
-		aTest.SetPostTransferResult(i, r);
-		}
-	// CMultiTransferTest is handled differently to the others.
-	// Whereas CSingleTransferTest logs just the return value
-	// of the check, here, we write back a result for each transfer
-	// so the return value from this function is not important
-	return KErrNone;
-	}
-
-TBool TCheckNoTransfer::IsZeroed(const TDmaTransferArgs& aTransferArgs, TUint8* aChunkBase) const
-	{
-	TAddressParms parms = GetAddrParms(aTransferArgs);
-	parms.Fixup(reinterpret_cast<TLinAddr>(aChunkBase));
-	const TAddrRange destination = parms.DestRange();
-
-	return destination.IsFilled(0);
-	}
-//////////////////////////////////////////////////////////////////////
-// MPreTransfer classes
-//////////////////////////////////////////////////////////////////////
-void TPreTransferIncrBytes::Setup(const CSingleTransferTest& aTest) const
-	{
-	if(gVerboseOutput)
-		{
-		RDebug::Printf("TPreTransferIncrBytes(CSingleTransferTest)");
-		}
-	TAddressParms params = GetAddrParms(aTest.TransferArgs());
-
-	TUint8* const chunkBase = aTest.Chunk().Base();
-	params.Fixup((TLinAddr)chunkBase);
-
-
-	Setup(params);
-	}
-
-void TPreTransferIncrBytes::Setup(const TAddressParms& aParams) const
-	{
-	if(gVerboseOutput)
-		{
-		RDebug::Printf("TPreTransferIncrBytes: setup memory buffers: src=0x%08x dst=0x%08x size=0x%08x",
-				aParams.iSrcAddr, aParams.iDstAddr, aParams.iTransferCount);
-		}
-	TUint8* const src = (TUint8*) aParams.iSrcAddr;
-	const TInt size = aParams.iTransferCount;
-
-	for(TInt i=0; i<size; i++)
-		{src[i] = (TUint8)i;} //each src byte holds its own offset (mod 256)
-
-	TUint8* const dst = (TUint8*) aParams.iDstAddr;
-	memclr(dst, size); //clear destination
-	}
-
-void TPreTransferIncrBytes::Setup(const CIsrRequeTest& aTest) const
-	{
-	if(gVerboseOutput)
-		{
-		RDebug::Printf("TPreTransferIncrBytes(CIsrRequeTest)");
-		}
-	if(!CheckBuffers(aTest))
-		{
-		RDebug::Printf("Successive transfer destinations may not overlap previous src or dst buffers");
-		RDebug::Printf("unless the whole transfer is an exact repeat of a previous one");
-		TEST_FAULT;
-		}
-
-	Setup(static_cast<CSingleTransferTest>(aTest)); // prepare the CSingleTransferTest parts
-
-	TIsrRequeArgsSet requeSet(aTest.GetRequeueArgs());
-
-	requeSet.Substitute(aTest.TransferArgs());
-
-	const TLinAddr chunkBase = (TLinAddr) aTest.Chunk().Base();
-	requeSet.Fixup(chunkBase);
-
-	while(!requeSet.IsEmpty())
-		{
-		TIsrRequeArgs args = requeSet.GetArgs();
-		Setup(args); // perform the setup operation for each TIsrRequeArgs
-		}
-	}
-
-void TPreTransferIncrBytes::Setup(const CMultiTransferTest& aTest) const
-	{
-	if(gVerboseOutput)
-		{
-		RDebug::Printf("TPreTransferIncrBytes(CMultiTransferTest)");
-		}
-
-	if(!CheckBuffers(aTest))
-		{
-		RDebug::Printf("Successive transfer destinations may not overlap previous src or dst buffers");
-		TEST_FAULT;
-		}
-
-	TUint8* const chunkBase = aTest.Chunk().Base();
-	const TInt transferCount = aTest.TransferCount();
-
-	// initialise buffers for each transfer
-	for(TInt i=0; i<transferCount; i++)
-		{
-		TAddressParms params = GetAddrParms(aTest.TransferArgs(i));
-
-		params.Fixup((TLinAddr)chunkBase);
-
-		Setup(params);
-		}
-	}
-
-TBool TPreTransferIncrBytes::CheckBuffers(const CIsrRequeTest& aTest) const
-	{
-	RArray<const TAddressParms> array;
-	array.AppendL(TAddressParms(aTest.TransferArgs()));
-
-	TIsrRequeArgsSet requeSet(aTest.GetRequeueArgs());
-	requeSet.Substitute(aTest.TransferArgs());
-
-	const TLinAddr chunkBase = (TLinAddr) aTest.Chunk().Base();
-	requeSet.Fixup(chunkBase);
-	while(!requeSet.IsEmpty())
-		{
-		const TIsrRequeArgs requeArgs = requeSet.GetArgs();
-		array.AppendL(requeArgs);
-		}
-
-	const TBool result = CheckBuffers(array);
-
-	array.Close();
-	return result;
-	}
-
-/**
-A CMultiTransferTest will wait for all transfers to complete
-before comapairing source and destination buffers. For this to be successful
-each transfer must be independent ie. no destination or source may be
-overwritten by another transfer and source buffers may not depend on an
-earlier transfer
-*/
-TBool TPreTransferIncrBytes::CheckBuffers(const CMultiTransferTest& aTest) const
-	{
-	TUint8* const chunkBase = aTest.Chunk().Base();
-	const TInt transferCount = aTest.TransferCount();
-
-	// assemble an array of TAddressParams from aTest, that
-	// can then be passed to CheckBuffers(RArray<TAddressParms>)
-	RArray<const TAddressParms> array;
-
-	for(TInt i=0; i<transferCount; i++)
-		{
-		TAddressParms params = GetAddrParms(aTest.TransferArgs(i));
-		params.Fixup((TLinAddr)chunkBase);
-
-		array.AppendL(params);
-		}
-
-	 // 2nd arg EFalse as there is no need to permit exact repeats
-	const TBool r = CheckBuffers(array, EFalse);
-
-	array.Close();
-	return r;
-	}
-
-/**
-Check that the destination of each TAddressParms does not overlap with
-any previous source or destination or that if it does the whole transfer
-matches.
-This is so that successive transfers do not overwrite the destinations or
-sources of preceeding ones.
-
-If aAllowExactRepeat is true then exactly matching transfers are allowed
-to test the case where a repeat transfer is required - though it can't
-then be determined just from looking at the buffers that the repeat was
-successful
-*/
-TBool TPreTransferIncrBytes::CheckBuffers(const RArray<const TAddressParms>& aTransferParams, TBool aAllowExactRepeat) const
-	{
-
-	const TInt count = aTransferParams.Count();
-
-	if(gVerboseOutput)
-		{
-		RDebug::Printf("CheckBuffers, %d transfers", count);
-		}
-
-	TBuf<128> buf;
-	for(TInt i=1; i<count; i++)
-		{
-		const TAddressParms& current = aTransferParams[i];
-
-		if(gVerboseOutput)
-			{
-			buf.Zero();
-			current.AppendString(buf);
-			RDebug::Print(_L("Check current: %S, against:"), &buf);
-			}
-
-		for(TInt j=0; j<i; j++)
-			{
-			const TAddressParms& previous = aTransferParams[j];
-			if(gVerboseOutput)
-				{
-				buf.Zero();
-				previous.AppendString(buf);
-				RDebug::Print(_L("Previous: %S"), &buf);
-				}
-
-			const TBool curDstOverlapsPrevTfer = previous.Overlaps(current.DestRange());
-			const TBool curSrcDependsOnPrevDest = current.SourceRange().Overlaps(previous.DestRange());
-			const TBool permitExactRepeat = aAllowExactRepeat && (current == previous);
-
-			const TBool ok = !(curDstOverlapsPrevTfer || curSrcDependsOnPrevDest) || permitExactRepeat;
-			if(!ok)
-				return EFalse;
-			}
-		}
-	return ETrue;
-	}
-//////////////////////////////////////////////////////////////////////
-// TTransferIter class
-//////////////////////////////////////////////////////////////////////
-void TTransferIter::operator++ ()
-	{
-	iPtr++; //the standard post increment
-	if(iElem < (iCfg->iElementsPerFrame-1))
-		{
-		iPtr += iCfg->iElementSkip;
-		iElem++;
-		iBytes++;
-		}
-	else
-		{
-		TEST_ASSERT(iElem == iCfg->iElementsPerFrame-1);
-		if(iFrame < iCfg->iFramesPerTransfer-1)
-			{
-			iPtr += iCfg->iFrameSkip;
-			iFrame++;
-			iBytes++;
-			iElem = 0;
-			}
-		else
-			{
-			//we have reached the end
-			TEST_ASSERT(iFrame == iCfg->iFramesPerTransfer-1);
-			iPtr = NULL;
-			}
-		}
-
-	Invariant();
-	}
-
-void TTransferIter::Invariant() const
-	{
-	const TInt elemSize = iCfg->iElementSize;
-	RTest test(_L("TTransferIter invariant"));
-	const TUint bytesTransfered = (
-			elemSize * (iFrame * iCfg->iElementsPerFrame + iElem)
-			+ ((TUint)iPtr % (elemSize))
-			);
-	test_Equal(iBytes, bytesTransfered);
-	test.Close();
-	}
-
-///////////////////////////////////////////////////////////
-// TTestCase
-///////////////////////////////////////////////////////////
-TTestCase::TTestCase(CDmaTest* aTest,
-   TBool aConcurrent,
-   const TDmaCapability aCap1,
-   const TDmaCapability aCap2,
-   const TDmaCapability aCap3,
-   const TDmaCapability aCap4,
-   const TDmaCapability aCap5
-   )
-:
-	iTest(aTest), iConcurrentTest(aConcurrent)
-	{
-	iChannelCaps[0] = aCap1;
-	iChannelCaps[1] = aCap2;
-	iChannelCaps[2] = aCap3;
-	iChannelCaps[3] = aCap4;
-	iChannelCaps[4] = aCap5;
-	}
-
-TResult TTestCase::TestCaseValid(const SDmacCaps& aChannelCaps) const
-	{
-	const TDmaCapability* cap = &iChannelCaps[0];
-
-	TResult ret = ERun;
-	//We assume that the array is empty at the first ENone found
-	//any caps after this wil be ignored
-	while(cap->iCapsReq != ENone)
-		{
-		TResult t = cap->CompareToDmaCaps(aChannelCaps);
-		if(t > ret) //this relies on the enum ordering
-			ret = t;
-		cap++;
-		}
-	return ret;
-	}
-
-TResult TTestCase::TestCaseValid(const TDmacTestCaps& aChannelCaps) const
-	{
-	const TDmaCapability* cap = &iChannelCaps[0];
-
-	TResult ret = ERun;
-	//We assume that the array is empty at the first ENone found
-	//any caps after this wil be ignored
-	while(cap->iCapsReq != ENone)
-		{
-		TResult t = cap->CompareToDmaCaps(aChannelCaps);
-		if(t > ret) //this relies on the enum ordering
-			ret = t;
-		cap++;
-		}
-	return ret;
-	}
-/**
-Will report whether a value held in aChannelCaps satisfies a
-requirement specfied by this object
-*/
-TBool TDmaCapability::RequirementSatisfied(const SDmacCaps& aChannelCaps) const
-	{
-	switch(iCapsReq)
-		{
-	case ENone:
-		return ETrue;
-	case EChannelPriorities:
-		TEST_FAULT;
-	case EChannelPauseAndResume:
-		return aChannelCaps.iChannelPauseAndResume == (TBool)iValue;
-	case EAddrAlignedToElementSize:
-		TEST_FAULT;
-	case E1DAddressing:
-		return aChannelCaps.i1DIndexAddressing == (TBool)iValue;
-	case E2DAddressing:
-		return aChannelCaps.i2DIndexAddressing == (TBool)iValue;
-	case ESynchronizationTypes:
-	case EBurstTransactions:
-	case EDescriptorInterrupt:
-	case EFrameInterrupt:
-	case ELinkedListPausedInterrupt:
-	case EEndiannessConversion:
-	case EGraphicsOps:
-	case ERepeatingTransfers:
-	case EChannelLinking:	
-		return aChannelCaps.iChannelLinking == (TBool)iValue;
-	case EHwDescriptors:
-		return aChannelCaps.iHwDescriptors == (TBool)iValue;
-	case ESrcDstAsymmetry:
-	case EAsymHwDescriptors:
-		TEST_FAULT;
-	case EBalancedAsymSegments:
-		return aChannelCaps.iBalancedAsymSegments == (TBool)iValue;
-	case EAsymCompletionInterrupt:
-		return aChannelCaps.iAsymCompletionInterrupt == (TBool)iValue;
-	case EAsymDescriptorInterrupt:
-		return aChannelCaps.iAsymDescriptorInterrupt == (TBool)iValue;
-	case EAsymFrameInterrupt:
-		return aChannelCaps.iAsymFrameInterrupt == (TBool)iValue;
-	default:
-		TEST_FAULT;
-		}
-
-	return EFalse;
-	}
-
-/**
-Will report whether a value held in aChannelCaps satisfies a
-requirement specfied by this object
-*/
-TBool TDmaCapability::RequirementSatisfied(const TDmacTestCaps& aChannelCaps) const
-	{
-	switch(iCapsReq)
-		{
-	case EPilVersion:
-		return TestValue(aChannelCaps.iPILVersion);
-	default:
-		return RequirementSatisfied(static_cast<SDmacCaps>(aChannelCaps));
-		}
-	}
-
-TResult TDmaCapability::CompareToDmaCaps(const SDmacCaps& aChannelCaps) const
-	{
-	const TBool reqSatisfied = RequirementSatisfied(aChannelCaps);
-	if(reqSatisfied)
-		{
-		return ERun;
-		}
-	else
-		{
-		return iFail ? EFail : ESkip;
-		}
-	}
-
-TResult TDmaCapability::CompareToDmaCaps(const TDmacTestCaps& aChannelCaps) const
-	{
-	const TBool reqSatisfied = RequirementSatisfied(aChannelCaps);
-	if(reqSatisfied)
-		{
-		return ERun;
-		}
-	else
-		{
-		return iFail ? EFail : ESkip;
-		}
-	}
-/**
-Test that aValue satisfies the comparrison (iCapsReqType) with the
-reference value held in iValue
-*/
-TBool TDmaCapability::TestValue(TUint aValue) const
-	{
-	switch(iCapsReqType)
-		{
-	case EEqual:
-		return aValue == iValue;
-	case EGTE:
-		return aValue >= iValue;
-	case ELTE:
-		return aValue <= iValue;
-	case EBitsSet:
-	case EBitsClear:
-	default:
-		TEST_FAULT;
-		}
-	return EFalse;
-	}
-
-static RTest test(_L("DMAv2 test"));
-
-//////////////////////////////////////////////////////////////////////
-// TTestRunner
-//////////////////////////////////////////////////////////////////////
-TTestRunner::TTestRunner()
-	{
-	// Open RDmaSession handle
-	TInt r = iDmaSession.Open();
-	TEST_ASSERT(r == KErrNone);
-
-	// Get PSI Test info
-	r = iDmaSession.GetTestInfo(iPslTestInfo);
-	TEST_ASSERT(r == KErrNone);
-
-	//Retrieve PSL cookies
-	GetPslCookie();
-
-	//Generate the DMA channel records
-	GenerateChannelRecord();
-	}
-
-TTestRunner::~TTestRunner()
-	{
-	RTest::CloseHandleAndWaitForDestruction(iDmaSession);
-	iTestCases.Close(); //TestRunner does not own test cases
-	iChannelRecords.Close();
-	iPslCookies.Close();
-	}
-
-void TTestRunner::AddTestCases(RPointerArray<TTestCase>& aTTestCases)
-	{
-	const TInt count = aTTestCases.Count();
-	for(TInt i=0; i < count; i++)
-		{
-		iTestCases.AppendL(aTTestCases[i]);
-		}
-	}
-
-void TTestRunner::RunTests()
-	{
-	//Print PslTestInfo
-	if(gVerboseOutput)
-		{
-		Print(iPslTestInfo);
-		}
-
-	//iterate through the test case array
-	const TInt testCaseCount = iTestCases.Count();
-	for(TInt i=0; i < testCaseCount; i++)
-		{
-		const TTestCase& testCase = *iTestCases[i];
-
-		//Here, we must create a test thread for each channel
-		RPointerArray<CTest> concurrentTests;
-
-		const TInt chanRecCount = iChannelRecords.Count();
-		for(TInt j=0; j < chanRecCount; j++)
-			{
-			const TChannelRecord& record = iChannelRecords[j];
-			const TDmacTestCaps& caps = record.iChannelCaps;
-
-			const TResult t = testCase.TestCaseValid(caps);
-
-			switch(t)
-				{
-			case ERun:
-				{
-				CDmaTest* dmaTest = static_cast<CDmaTest*>(testCase.iTest->Clone());
-				TEST_ASSERT(dmaTest != NULL);
-
-				dmaTest->SetChannelCookie(record.iCookie);
-				dmaTest->SetupL();
-				if(testCase.iConcurrentTest)
-					{
-					//Add test to array to be run concurrently
-					TInt r = concurrentTests.Append(dmaTest);
-					TEST_ASSERT(r == KErrNone);
-					}
-				else
-					{
-					dmaTest->Announce();
-					//Run test in this thread
-					(*dmaTest)();
-					TBool result = dmaTest->Result();
-					TEST_ASSERT(result);
-
-					delete dmaTest;
-					}
-
-				break;
-				}
-			case ESkip:
-				if(gVerboseOutput)
-				{
-				RDebug::Printf("Skipping test-case %S, PSL channel %d", &testCase.iTest->Name(), record.iCookie);
-				}
-				break;
-			case EFail:
-				if(gVerboseOutput)
-				{
-				RDebug::Printf("Failling test-case %S, PSL channel %d", &testCase.iTest->Name(), record.iCookie);
-				}
-				TEST_FAULT;
-			default:
-				TEST_FAULT;
-				}
-			//Depending on the value of iConcurrentTest the test runner will either block until the thread has completed or
-			//alternatively run the current test case on the next channel:
-
-			//if the test case has been run on all channels it will then  wait for all threads to complete.
-			}
-
-		// Run the tests which should happen concurrently
-		const TInt count = concurrentTests.Count();
-		if(count>0)
-			{
-			RDebug::Printf("== Begin concurrent test run ==");
-
-			TInt i;											// VC++
-			for(i=0; i<count; i++)
-				{
-				concurrentTests[i]->Announce();
-				}
-
-			MultipleTestRun(concurrentTests);
-			for(i=0; i<count; i++)
-				{
-				TBool result = static_cast<CDmaTest*>(concurrentTests[i])->Result();
-				TEST_ASSERT(result);
-				}
-			RDebug::Printf("== End concurrent test run ==");
-			}
-
-		concurrentTests.ResetAndDestroy();
-		}
-	}
-
-void TTestRunner::GetPslCookie()
-	{
-	//Get Sb Channel cookies
-	for(TInt sb_channelcount=0; sb_channelcount<iPslTestInfo.iMaxSbChannels; sb_channelcount++)
-		{
-		iPslCookies.AppendL(iPslTestInfo.iSbChannels[sb_channelcount]);
-		}
-
-	//Get Db Channel cookies
-	for(TInt db_channelcount=0; db_channelcount<iPslTestInfo.iMaxDbChannels; db_channelcount++)
-		{
-		iPslCookies.AppendL(iPslTestInfo.iDbChannels[db_channelcount]);
-		}
-
-	//Get Sg Channel cookies
-	for(TInt sg_channelcount=0; sg_channelcount<iPslTestInfo.iMaxSgChannels; sg_channelcount++)
-		{
-		iPslCookies.AppendL(iPslTestInfo.iSgChannels[sg_channelcount]);
-		}
-	}
-
-void TTestRunner::GenerateChannelRecord()
-	{
-	//for each PSL cookie
-	for(TInt count=0; count<iPslCookies.Count(); count++)
-		{
-		//Get channel cookie
-		const TUint pslCookie = iPslCookies[count];
-		TUint sessionCookie;
-		TInt r = iDmaSession.ChannelOpen(pslCookie, sessionCookie);
-		TEST_ASSERT(r == KErrNone);
-		if(gVerboseOutput)
-		{
-		RDebug::Printf("Channel PSL Cookie[%d]  :0x%08x",count,pslCookie);
-		}
-
-		TChannelRecord dmaChannelRecord;
-		dmaChannelRecord.iCookie = pslCookie;
-
-		//Get Channel Caps
-		r = iDmaSession.ChannelCaps(sessionCookie, dmaChannelRecord.iChannelCaps);
-		TEST_ASSERT(r == KErrNone);
-
-		r = iDmaSession.ChannelClose(sessionCookie);
-		TEST_ASSERT(r == KErrNone);
-
-		//Append array
-		iChannelRecords.AppendL(dmaChannelRecord);
-		}
-	}
-//////////////////////////////////////////////////////////////////////
-// Global test functions and E32Main
-//////////////////////////////////////////////////////////////////////
-
-/**
-Displayed if used supplied no parameters, garbage, or a ? in the parameters
-*/
-void PrintUsage()
-	{
-	test.Printf(_L("*** DMA TEST FRAMEWORK ***\n"));
-	test.Printf(_L("Usage : t_dma2.exe [/option]\n"));
-	test.Printf(_L("  /V or /VERBOSE  = Control test output\n"));
-	test.Printf(_L("  /S or /SELFTEST = Run DMA self tests\n"));
-	test.Printf(_L("  /simple = Run only simple transfer tests\n"));
-	test.Printf(_L("  /callback = Run only callback tests\n"));
-	test.Printf(_L("  /multi = Run only multipart transfer tests\n"));
-	test.Printf(_L("  /isrdfc = Run only isr and dfc tests\n"));
-	test.Printf(_L("  /isreque = Run only isr reque tests\n"));
-	test.Printf(_L("  /bench = Run only benchmark tests\n"));
-	test.Printf(_L("  /suspend = Run only pause and resume tests\n"));
-	test.Printf(_L("  /graphic = Run only graphic tests\n"));
-	test.Printf(_L("  /channel = Run only DMA channel (opening and closing) tests\n"));
-	test.Printf(_L("  /queue = Run only queue tests\n"));
-	test.Printf(_L("  /fragment = Run only fragmentation related tests\n"));
-	test.Printf(_L("  /request = Run only requests tests related tests\n"));
-	test.Printf(_L("\n"));
-	}
-
-void ProcessCommandLineL()
-{
-	test.Printf(_L("Process command line arguments\n"));
-
-	TInt cmdLineLength(User::CommandLineLength());
-	HBufC* cmdLine = HBufC::NewMaxLC(cmdLineLength);
-	TPtr cmdLinePtr = cmdLine->Des();
-	User::CommandLine(cmdLinePtr);
-	TBool  tokenParsed(EFalse);
-
-	TLex args(*cmdLine);
-	args.SkipSpace(); // args are separated by spaces
-	
-	// first arg is the exe name, skip it
-	TPtrC cmdToken = args.NextToken();
-	HBufC* tc = HBufC::NewLC(KParameterTextLenMax);
-	*tc = cmdToken;
-	while (tc->Length())
-		{
-		tokenParsed = EFalse;
-		
-		// '/?' help wanted flag '?' or /? parameter
-		if ((0== tc->FindF(_L("?"))) || (0==tc->FindF(_L("/?")))) 
-			{
-			gHelpRequested = ETrue;
-			tokenParsed = ETrue;
-			}	
-		
-		// '/SELFTEST'			
-		if ((0== tc->FindF(KArgSelfTest)) || (0==tc->FindF(KArgSelfTest2))) 
-			{
-			// Run self test
-			test.Printf(_L("Command Line Options:Selftest option specified.\n"));
-			gSelfTest = ETrue;
-			tokenParsed = ETrue;
-			}
-
-		// '/VERBOSE' option	
-		if ((0== tc->FindF(KArgVerboseOutput)) || (0==tc->FindF(KArgVerboseOutput2)))
-			{ 
-			test.Printf(_L("Command Line Options:Verbose option specified.\n"));
-			gVerboseOutput = ETrue;
-			tokenParsed = ETrue;			
-			}
-
-		// '/suspend' option
-		if ((0== tc->FindF(KArgSuspendTest)))
-			{
-			gSuspend = ETrue;
-			tokenParsed = ETrue;
-			}	
-		
-		// '/simple' option
-		if ((0== tc->FindF(KArgSimpleTest)))
-			{
-			gSimpleTest = ETrue;
-			tokenParsed = ETrue;
-			}	
-		
-		// '/multi' option
-		if ((0== tc->FindF(KArgMultiPartTest)))
-			{
-			gMultiPart = ETrue;
-			tokenParsed = ETrue;
-			}	
-	
-		// '/callback' option
-		if ((0== tc->FindF(KArgCallBackTest)))
-			{
-			gCallBack = ETrue;
-			tokenParsed = ETrue;
-			}	
-		
-		// '/IsrAndDfc' option
-		if ((0== tc->FindF(KArgIsrDfcTest)))
-			{
-			gIsrAndDfc  = ETrue;
-			tokenParsed = ETrue;
-			}	
-		
-		// '/IsrReque' option
-		if ((0== tc->FindF(KArgIsrequeTest)))
-			{
-			gIsrReque = ETrue;
-			tokenParsed = ETrue;
-			}	
-
-		// '/Benchmark' option
-		if ((0== tc->FindF(KArgBenchmarkTest)))
-			{
-			gBenchmark = ETrue;
-			tokenParsed = ETrue;
-			}	
-
-		// '/Queue' option
-		if ((0== tc->FindF(KArgQueueTest)))
-			{
-			gQueue = ETrue;
-			tokenParsed = ETrue;
-			}	
-
-		// '/Fragment' option
-		if ((0== tc->FindF(KArgFragmentTest)))
-			{
-			gFragment = ETrue;
-			tokenParsed = ETrue;
-			}	
-		
-		// '/Channel' option
-		if ((0== tc->FindF(KArgChannelTest)))
-			{
-			gChannel = ETrue;
-			tokenParsed = ETrue;
-			}	
-		
-		// '/Graphic' option
-		if ((0== tc->FindF(KArgGraphicTest)))
-			{
-			gGraphic = ETrue;
-			tokenParsed = ETrue;
-			}	
-
-		// '/Request' option
-		if ((0== tc->FindF(KArgRequestTest)))
-			{
-			gRequest = ETrue;
-			tokenParsed = ETrue;
-			}	
-	
-		if (!tokenParsed)
-			{
-			// warn about unparsed parameter
-			test.Printf(_L("Warning: '%lS'??? not parsed\n"), tc);
-			gHelpRequested = ETrue;
-			}
-			
-		// next parameter
-		*tc = args.NextToken();
-		}
-	CleanupStack::PopAndDestroy(tc);
-	CleanupStack::PopAndDestroy(cmdLine);
-}
-
-void RunDMATests()
-	{
-	test.Start(_L("Creating test runner\n"));
-	TTestRunner testRunner;
-
-	test.Next(_L("Add global test cases to test runner\n"));
-
-	if (gSimpleTest) //Add only simple tranfer test cases
-	{
-		testRunner.AddTestCases(TestArraySimple);
-	}
-	else if (gCallBack)  //Add only callback test cases
-	{
-		testRunner.AddTestCases(TestArrayCallback);
-	}
-	else if (gIsrReque)  //Add only ISR Reque test cases
-	{
-		testRunner.AddTestCases(TestArrayIsrReque);
-	}
-	else if (gMultiPart)  //Add only Multipart test cases
-	{
-		testRunner.AddTestCases(TestArrayMultiPart);
-	}
-	else if (gIsrAndDfc)  //Add only IsrAndDfc test cases
-	{
-		testRunner.AddTestCases(TestArrayIsrAndDfc);
-	}
-	else if (gBenchmark)  //Add only Benchmark test cases
-	{
-		testRunner.AddTestCases(TestArrayBenchmark);
-	}
-	else if (gGraphic)  //Add only 2D test cases
-	{
-		testRunner.AddTestCases(TestArray2DTest);
-	}
-	else if (gFragment)  //Add only Fragment test cases
-	{
-		testRunner.AddTestCases(TestArrayFragment);
-	}
-	else if (gChannel)  //Add only Channel test cases
-	{
-		testRunner.AddTestCases(TestArrayChannel);
-	}
-	else if (gSuspend)  //Add only Suspend test cases
-	{
-		testRunner.AddTestCases(TestArraySuspend);
-	}
-	else if (gQueue)  //Add only queue test cases
-	{
-		testRunner.AddTestCases(TestArrayQueue);
-	}
-	else if (gRequest)  //Add only request test cases
-	{
-		testRunner.AddTestCases(TestArrayRequest);
-	}
-	else
-	{
-		testRunner.AddTestCases(TestArray);//Add all test cases
-	}
-
-	test.Next(_L("call TTestRunner::RunTests()\n"));
-	testRunner.RunTests();
-
-	test.End();
-	}
-
-
-struct TSimTest
-	{
-	TUint iPslId;
-	TBool iFragment;
-	};
-
-const TSimTest KSimTests[] =
-	{
-		{0, EFalse},
-		{1, EFalse},
-		{2, ETrue},
-		{3, ETrue},
-	};
-
-const TInt KSimTestsCount = ARRAY_LENGTH(KSimTests);
-
-void RunSimDMATests()
-	{
-	test.Start(_L("Run simulated DMAC tests\n"));
-
-	test.Next(_L("Open session"));
-	RDmaSession session;
-	TInt r = session.OpenSim();
-	test_KErrNone(r);
-
-	for(TInt i=0; i<KSimTestsCount; i++)
-		{
-		TUint pslId = KSimTests[i].iPslId;
-		TBool doFrag = KSimTests[i].iFragment;
-
-		test.Start(_L("Open channel"));
-		TUint channelCookie=0;
-		r = session.ChannelOpen(pslId, channelCookie);
-		test.Printf(_L("Open channel %d, cookie recived = 0x%08x\n"), pslId, channelCookie);
-		test_KErrNone(r);
-
-		test.Next(_L("Create Dma request"));
-
-		TUint reqCookie=0;
-		r = session.RequestCreate(channelCookie, reqCookie);
-		test.Printf(_L("cookie recived = 0x%08x\n"), reqCookie );
-		test_KErrNone(r);
-
-		if(doFrag)
-			{
-			test.Next(_L("Fragment request"));
-			const TInt size = 128 * KKilo;
-			TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr);
-			r = session.FragmentRequest(reqCookie, transferArgs);
-			test_KErrNone(r);
-			}
-
-		test.Next(_L("Destroy Dma request"));
-		r = session.RequestDestroy(reqCookie);
-		test_KErrNone(r);
-
-		test.Next(_L("Channel close"));
-		r = session.ChannelClose(channelCookie);
-		test_KErrNone(r);
-		test.End();
-		}
-
-	test.Next(_L("Close session"));
-	RTest::CloseHandleAndWaitForDestruction(session);
-
-	test.End();
-	}
-
-TInt E32Main()
-	{
-	__UHEAP_MARK;
-	test.Title();
-
-	gHelpRequested = EFalse;
-	TInt r;
-
-	// Create the new trap-cleanup mechanism
-	CTrapCleanup* cleanup = CTrapCleanup::New();
-
-	if (cleanup == NULL)
-		{
-		return KErrNoMemory;
-		}
-
-	// Process the command line parameters for batch/etc
-	TRAPD(err, ProcessCommandLineL());
-	if (err != KErrNone)
-		{
-		User::Panic(_L("DMA test run memory failure"), KErrNoMemory);
-		}
-
-	if (gHelpRequested)
-		{
-		PrintUsage();
-		User::Leave(-2);	// nothing to do!
-		}
-	test.Start(_L("Loading test LDD"));
-	//load either the new test ldd, d_dma2.ldd,
-	//or d_dma2_compat.ldd - an ldd linked against
-	//the old DMA framework
-	_LIT(KDma, "D_DMA2.LDD");
-	r = User::LoadLogicalDevice(KDma);
-	const TBool dma2Loaded = ((r == KErrNone) || (r == KErrAlreadyExists));
-
-	_LIT(KDma2Compat, "D_DMA2_COMPAT.LDD");
-	r = User::LoadLogicalDevice(KDma2Compat);
-	const TBool dma2CompatLoaded = ((r == KErrNone) || (r == KErrAlreadyExists));
-
-	if (!(dma2Loaded || dma2CompatLoaded))
-		{
-		test.Printf(_L("Hardware DMA test driver not found - will run tests on simulated DMAC only\n"));
-		}
-	else if (dma2Loaded && !dma2CompatLoaded)
-		{
-		test.Printf(_L("Loaded %S\n"), &KDma);
-		}
-	else if (!dma2Loaded && dma2CompatLoaded)
-		{
-		test.Printf(_L("Loaded %S\n"), &KDma2Compat);
-		}
-	else
-		{
-		test.Printf(_L("The ROM contains %S and %S - only one should be present\n"), &KDma, &KDma2Compat);
-		TEST_FAULT;
-		}
-
-	const TBool dmaHwPresent = (dma2Loaded || dma2CompatLoaded);
-
-	_LIT(KDma2Sim, "D_DMA2_SIM.LDD");
-
-	r = User::LoadLogicalDevice(KDma2Sim);
-	const TBool dma2SimLoaded = ((r == KErrNone) || (r == KErrAlreadyExists));
-	if (dma2SimLoaded)
-		{
-		test.Printf(_L("Loaded %S\n"), &KDma2Sim);
-		}
-	else
-		{
-		test.Printf(_L("Failed to load %S, r=%d\n"), &KDma2Sim, r);
-		test(EFalse);
-		}
-
-	// Turn off evil lazy dll unloading
-	RLoader l;
-	test(l.Connect()==KErrNone);
-	test(l.CancelLazyDllUnload()==KErrNone);
-	RTest::CloseHandleAndWaitForDestruction(l);
-
-	__KHEAP_MARK;
-
-	if (gSelfTest) //Run self tests if specified on command line
-		{
-		SelfTests();
-		}
-
-	RunSimDMATests();
-	if (dmaHwPresent)
-		{
-		RunDMATests();
-		}
-
-	// Wait for the supervisor thread to run and perform asynchronous
-	// cleanup, so that kernel heap space will be freed
-	r = UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, (TAny*)5000, 0);
-	test_KErrNone(r);
-	__KHEAP_MARKEND;
-
-	if(dmaHwPresent)
-		{
-		r = User::FreeLogicalDevice(KTestDmaLddNameHw);
-		test_KErrNone(r);
-		}
-	r = User::FreeLogicalDevice(KTestDmaLddNameSim);
-	test_KErrNone(r);
-
-	test.End();
-	test.Close();
-
-	delete cleanup;
-
-	__UHEAP_MARKEND;
-	return 0;
-	}