const TInt trans64K_1 = ((64 * KKilo) -1); // 65535

//----------------------------------------------------------------------------------------------

//! TestCaseID      KBASE-DMA-2571

//! TestType        CIT

//! PREQ            REQ

//! TestCaseDesc    This test verifies the correct behavior of CancelAll API in the new DMA 

//!					framework 

//! TestActions     

//!						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.

//!

//!

//! TestExpectedResults 1.  DMA channel opens and KErrNone returned.

//!						2.  DMA queue request created and KErrNone returned.

//!						3.  CancelAll () cancels all queued request.

//!						4.  All queued request are cancelled

//!						5.	DMA Request completes

//! TestPriority        High

//! TestStatus          Implemented

//----------------------------------------------------------------------------------------------

namespace CancelAllTest

	{

	const TInt size = 2 * KMega;

	const TDmaTransferArgs transferArgArray[] = {

		TDmaTransferArgs(0, size, size, KDmaMemAddr),

		TDmaTransferArgs(2 * size, 3 * size, size, KDmaMemAddr)

	};

	TResultSet noTransferExpected = TResultSet()

		.PostTransferResult(KErrNone)

		.CallbackRecord(TCallbackRecord::Empty());

	const TResultSet expected[] =

		{

		TResultSet(noTransferExpected),

		TResultSet(noTransferExpected)

		};

	// Test that 2 requests can be queued on a paused channel

	// then cleared using CancelAll.

	// It is expected that no data will have been transferred to the

	// destination buffer.

	CCancelAllTest testcancelall =

		CCancelAllTest(_L("CancelAllTest : Cancel and verify cancellation of requests"), 1, transferArgArray, expected, ARRAY_LENGTH(transferArgArray))

			.SetPreTransferTest(&KPreTransferIncrBytes)

			.SetPostTransferTest(&KCheckNoTransfer);

	TTestCase testCase(&testcancelall,EFalse,capAboveV1,pauseRequired_skip);

	}

//--------------------------------------------------------------------------------------------

//! TestCaseID      KBASE-DMA-2569

//! TestType        CIT

//! PREQ            REQ

//! TestCaseDesc    This test verifies the correct behavior of Pause and Resume API in the new DMA 

//!					framework 

//!

//! TestActions     

//!						1.	Open a DMA channel for a transfer.

//!						2.  Setup a DMA request and time how long the transfer takes

//!						3.	Pause the DMA channel

//!						4.  Repeat DMA transfer (queued asynchronously)

//!						5.  Resume DMA Channel

//! 

//!	TestExpectedResults 1.  DMA channel opens and KErrNone returned.

//!						2.  DMA request created and KErrNone returned.

//!						3.  DMA channel Paused.

//!						4.  Request queued and waits until Resume is called

//!						5.	DMA Request completes

//!

//! TestPriority        High

//! TestStatus          Implemented

//----------------------------------------------------------------------------------------------

namespace PauseResumeApiTest

	{

	const TInt srcAddr		= 0;

	const TInt desAddr		= 2 * KMega;	

	const TInt transferSize = 1 * KMega;	

	TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize, KDmaMemAddr);

	const TResultSet expectedResults(threadCallback);

	CPauseResumeTest testPauseResume = CPauseResumeTest(_L("Pause and Resume Test"), 1, transferArgs, expectedResults); 

	TTestCase testCasePauseResume(&testPauseResume, EFalse, capAboveV1,pauseRequired_skip);	

	}

//--------------------------------------------------------------------------------------------

//! TestCaseID      KBASE-DMA-2560

//! TestType        CIT

//! PREQ            REQ

//! TestCaseDesc    Simple DMA transfer test using CSingleTransferTest and New DMA APIs

//!

//! TestActions     

//!						1.	Open a DMA channel for a transfer.

//!						2.	Create single transfer test and run test

//!				

//!

//!

//! TestExpectedResults 

//!						1.  DMA channel opens and KErrNone returned.

//!						2.	DMA transfer completes with no errors.

//! TestPriority        High

//! TestStatus          Implemented

	TTestCase testCase(new (ELeave) CMultiVersionTest(&simpleTest), EFalse);

	TTestCase testCaseConcurrent(new (ELeave) CMultiVersionTest(&simpleTest), ETrue);

//! TestCaseID      KBASE-DMA-2573

//! TestType        CIT

//! PREQ            REQ

//! TestCaseDesc    DMA ISR Callback test (Isr Callback - use old request Ctor)

//! TestActions     

//!						1.	Setup DMA transfer to request a callback from ISR using old style DDmaRequest.

//!						2.	Create single transfer test and run test

//!						3.	Verify that DDmaRequest request fails

//! TestExpectedResults 

//!						1.  DMA channel opens and KErrNone returned.

//!						2.	DMA transfer created with no errors.

//!						3.	DDmaRequest request fails. 

//!						

//! TestPriority        High

//! TestStatus          Implemented

//! TestCaseID      KBASE-DMA-2574,KBASE-DMA-2575

//! TestType        CIT

//! PREQ            REQ

//! TestCaseDesc    DMA ISR Reque test

//! TestActions     

//!					1.	Setup DMA transfer to request a callback from ISR.

//!					2.	Set up ISR to requeue the DMA request on the same channel and adjust its transfer parameters.

//!					3.	Create single transfer test and run test

//!					4.	Verify a client can queue the just completed DMA request from within an ISR callback.

//! TestExpectedResults 

//!					

//!					DMA transfer completes and just completed request can be requeued from within an ISR 

//!					callback on the same channel. Requeued DMA request completes successfully

//! TestPriority        High

//! TestStatus          Implemented

	//-------------------------------------------------------------

	//This case requeues 4 transfers at the end of an ISR callback

	//-------------------------------------------------------------

	//---------------------------------------------------------------

	///This case requeues 4 transfers at the end of a thread callback

	//---------------------------------------------------------------

	//----------------------------------------------------------------------------------------------

	// This case requeues a transfer from within an thread callback after changing the transfer size

	//----------------------------------------------------------------------------------------------

	//--------------------------------------------------------------------------------------------

	// This case requeues a just completed request from within an ISR callback 

	//--------------------------------------------------------------------------------------------

		// The transfer size has been made bigger than 4K so that we do not miss the second interrupt when tracing 

		// enabled is. This indicates the PSL's interrupt handler misses an interrupt if it occurs during the interrupt.

	//--------------------------------------------------------------------------------------------

	// This case requeues a request from within an ISR callback using invalid requeue parameters

	//--------------------------------------------------------------------------------------------

	//--------------------------------------------------------------------------------------------

	// This case requeues a request containing more than 1 fragment from within an ISR callback

	// 

	//		

	// This test case is currently caught by a FAULT instead of a return code

	// as expected. Currently, the facility to return an error code to the test

	// framework is not yet supported.

	//

	// It has been implemented to expect an error code of KErrGeneral as requeues for request that

	// contains more than one fragments are not allowed. 

	//--------------------------------------------------------------------------------------------

		const TRequestResults isrequestResult(KErrNone, 2); // request contains 2 fragments

		const TCallbackRecord callbackRecord = TCallbackRecord(TCallbackRecord::EIsr, 1).IsrRedoResult(KErrGeneral);

		TRequestResults results2Fragments = TRequestResults(isrequestResult).FragmentCount(2); 

	}	

//! TestCaseID      PBASE-DMA-FUNC-2586

//! TestType        CIT

//! PREQ            REQ

//! TestCaseDesc    DMA Multiple transfer test

//! TestActions     

//!						1.Setup DMA transfer to using muliple transfers.

//!						2.Create multipart transfer test and run test.	

//! TestExpectedResults 

//!						1.  DMA tranfer set up with no errors. 

//!						2.	Multipart transfer tests completes with no issues.		

//! TestPriority        High

//! TestStatus          Implemented

		TDmaTransferArgs(2 * size, 3 * size, size, KDmaMemAddr)

//! TestCaseID      KBASE-DMA-2580

//! TestType        CIT

//! PREQ            REQ

//! TestCaseDesc    These tests attempt to queue ISR cb requests while the queue is not 

//!					empty and queing normal requests when an ISR cb is pending

//! TestActions     

//!				

//!					1.	Setup DMA transfer to request a callback from ISR.

//!					2.	Create single transfer test and run test

//!					3.	Queue another request using Queue()before ISR Callback completion

//!					4.	Verify a DMA framework flags an error.

//! TestExpectedResults 

//!					DMA framework flags an error  if ISR callback has not been executed 

//!					for the last time without re-queueing the initial transfer request		

//! TestPriority        High

//! TestStatus          Implemented

	// This test case needs a long transfer so that 1st request is still queued when the second 

	// one is queued. The use of Pause is recommended in order to guarantee this. For this case, 

	// the size has been selected to ensure that the first isr callback request in IsrBeforeDfc

	// will only have one fragment

				.SetPostTransferTest(&KCompareSrcDst)

				.PauseWhileQueuing();

		TTestCase testCase(&dfcBeforeIsr, EFalse, pauseRequired_skip, capAboveV1);

				.SetPostTransferTest(&KCompareSrcDst)

				.PauseWhileQueuing();

		TTestCase testCase(&dfcBeforeIsr, EFalse, pauseRequired_skip, capAboveV1);

//! TestCaseID      PBASE-DMA-FUNC-2587

//! TestType        CIT

//! PREQ            REQ

//! TestCaseDesc    DMA 2D transfer test

//! TestActions     

//!						1. Set up DMA transfer using TDmaTransArgs parameters specified in order to

//!						   rotate an image by 90 degrees clockwise.

//!						2. Verify that destination buffer gets transformed according to the DMA

//!						   transfer arguments after transfer.

//! TestExpectedResults 

//!						1. DMA tranfer set up with no errors. 

//!						2. Destination buffer gets transformed accordingly.

//! TestPriority        High

//! TestStatus          Implemented