/*

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

* This file contains statically defined test cases, a pointer to each

* new test case should be entered in StaticTestArray

*

*/

#include "t_dma2.h"

#include "cap_reqs.h"

const TCallbackRecord threadCallback(TCallbackRecord::EThread,1);

const TCallbackRecord isrCallback(TCallbackRecord::EIsr,1);

const TInt size = 128 * KKilo;

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

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

namespace Simple_1

	{

	TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr);

	const TResultSet expectedResults(threadCallback);

	CSingleTransferTest simpleTest(_L("Simple Test - New DMA APIs"), 1, transferArgs, expectedResults);

	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

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

namespace Callback

	{

	TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr);

	const TResultSet expectedResults(isrCallback);

	CSingleTransferTest isrTest(_L("Isr Callback"), 1, transferArgs, expectedResults);

	TTestCase testCase(&isrTest, EFalse, capAboveV1);

	const TRequestResults fragmentFails = TRequestResults().

		FragmentationResult(KErrArgument).

		QueueResult(KErrUnknown);

	const TResultSet expectedResultsFail = TResultSet(EFalse).

		ChannelOpenResult(KErrNone).

		RequestResult(fragmentFails).

		PostTransferResult(1); // PostTransferResult of 1 means buffers don't match

	CSingleTransferTest isrTestOldRequest = CSingleTransferTest(_L("Isr Callback - use old request Ctor"), 1, transferArgs, expectedResultsFail)

		.UseNewRequest(EFalse);

	TTestCase testCaseOldRequest(&isrTestOldRequest, EFalse, capAboveV1);

	}

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

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

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

namespace ISR_Reque

	{

	const TInt size = 4 * KKilo;

	TDmaTransferArgs tferArgs(0, 2*size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr);

	const TRequestResults requestResult(KErrNone, 1); // request must be in a single fragment

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

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

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

	namespace endOnIsrCb

		{

		TIsrRequeArgs requeArgs[] = {

			TIsrRequeArgs(),

			TIsrRequeArgs(size,3*size,size,0, ETrue),

			TIsrRequeArgs(size,4*size,size,0, ETrue),

			TIsrRequeArgs(0,5*size,size,0, ETrue),

		};

		const TInt count = ARRAY_LENGTH(requeArgs);

		// we expect a cb for each requeue + 1 for the original

		// transfer

		const TCallbackRecord callbackRecord = TCallbackRecord(TCallbackRecord::EIsr, count + 1).IsrRedoResult(KErrNone);

		const TResultSet expected(KErrNone, requestResult, KErrNone, callbackRecord);

		TTestCase testCase(new (ELeave) CIsrRequeTest(_L("4 Requeues - end on isr cb"), 1, tferArgs, requeArgs, count, expected, &KPreTransferIncrBytes, &KCompareSrcDst), ETrue, capAboveV1);

		}

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

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

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

	namespace endOnThreadCb

		{

		TIsrRequeArgs requeArgs[] = {

			TIsrRequeArgs(),

			TIsrRequeArgs(size,3*size,size,0, ETrue),

			TIsrRequeArgs(size,4*size,size,0, ETrue),

			TIsrRequeArgs(0,5*size,size,0, EFalse),

		};

		const TInt count = ARRAY_LENGTH(requeArgs);

		const TCallbackRecord callbackRecord = TCallbackRecord(TCallbackRecord::EThread, count + 1).IsrRedoResult(KErrNone);

		const TResultSet expected(KErrNone, requestResult, KErrNone, callbackRecord);

		TTestCase testCase(new (ELeave) CIsrRequeTest(_L("4 Requeues - end on thread cb"), 1, tferArgs, requeArgs, count, expected, &KPreTransferIncrBytes, &KCompareSrcDst), ETrue, capAboveV1);

		}

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

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

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

	namespace changeSize

		{

		TIsrRequeArgs requeArgs[] = {

			TIsrRequeArgs(3*size,5*size,2*size,0, EFalse),

		};

		const TInt count = ARRAY_LENGTH(requeArgs);

		const TCallbackRecord callbackRecord = TCallbackRecord(TCallbackRecord::EThread, count + 1).IsrRedoResult(KErrNone);

		const TResultSet expected(KErrNone, requestResult, KErrNone, callbackRecord);

		TTestCase testCase(new (ELeave) CIsrRequeTest(_L("1 Requeues - change transfer size"), 1, tferArgs, requeArgs, count, expected, &KPreTransferIncrBytes, &KCompareSrcDst), ETrue, capAboveV1);

		}

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

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

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

	namespace endOnRedo

		{

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

		const TInt size = 0x10000;

		TDmaTransferArgs tferArgs(0, 2*size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr);

		TIsrRequeArgs requeArgs[] = {

			TIsrRequeArgs(3*size,5*size,2*size,0, ETrue),

			TIsrRequeArgs() //repeat the previous transfer

		};

		const TInt count = ARRAY_LENGTH(requeArgs);

		const TCallbackRecord callbackRecord = TCallbackRecord(TCallbackRecord::EIsr, count + 1).IsrRedoResult(KErrNone);

		const TResultSet expected(KErrNone, requestResult, KErrNone, callbackRecord);

		TTestCase testCase(new (ELeave) CIsrRequeTest(_L("2 Requeues - Isr redo request repeated"), 1, tferArgs, requeArgs, count, expected, &KPreTransferIncrBytes, &KCompareSrcDst), EFalse, capAboveV1);

		}

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

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

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

	namespace invalidAddresses

		{

		TIsrRequeArgs requeArgs[] = {

			TIsrRequeArgs(size, size)

		};

		const TInt count = ARRAY_LENGTH(requeArgs);

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

		const TResultSet expected(KErrNone, requestResult, KErrUnknown, callbackRecord);

		// pre and post test would fail because of bad requeue parameters

		TTestCase testCase(new (ELeave) CIsrRequeTest(_L("Requeue with matching addresses"), 1, tferArgs, requeArgs, count, expected, NULL, NULL), ETrue, capAboveV1);

		}

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

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

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

	namespace multipleFragments

		{

		TIsrRequeArgs requeArgs[] = {

			TIsrRequeArgs()

		};

		const TInt count = ARRAY_LENGTH(requeArgs);

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

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

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

		const TResultSet expected(KErrNone, results2Fragments, KErrNone, callbackRecord);

		TTestCase testCase(new (ELeave) CIsrRequeTest(_L("Attempt to Requeue 2 fragment request"), 1, tferArgs, requeArgs, count, expected, &KPreTransferIncrBytes, &KCompareSrcDst, size/2), ETrue, capAboveV1);

		}

	}	

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

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

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

namespace Multipart

	{

	// need long transfer, to try and force adjacent

	// requests to be concatinated

	const TInt size = 2 * KMega;

	const TDmaTransferArgs transferArgArray[] = {

		TDmaTransferArgs(0, size, size, KDmaMemAddr),

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

	};

	const TResultSet expected[] =

		{

		TResultSet(),

		TResultSet()

		};

	CMultiTransferTest multipart =

		CMultiTransferTest(_L("Sg request concatination"), 1, transferArgArray, expected, ARRAY_LENGTH(transferArgArray))

			.SetPreTransferTest(&KPreTransferIncrBytes)

			.SetPostTransferTest(&KCompareSrcDst);

	TTestCase testCase(&multipart, EFalse, hwDesWanted_skip);

	}

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

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

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

namespace IsrAndDfc

	{

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

	const TInt size = 0x40000;

	TDmaTransferArgs dfcTransfer(0, size, size, KDmaMemAddr);

	TDmaTransferArgs isrTransfer(2*size, 3*size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr);

	const TResultSet success = TResultSet();

	TResultSet queueFailure = TResultSet().

			RequestResult(TRequestResults().QueueResult(KErrGeneral)).

			CallbackRecord(TCallbackRecord::Empty()).

			PostTransferResult(1);

	namespace DfcBeforeIsr

		{

		const TDmaTransferArgs transferArgArray[] = {

			dfcTransfer,

			isrTransfer

		};

		const TResultSet expected[] =

			{

			success,

			queueFailure

			};

		CMultiTransferTest dfcBeforeIsr =

			CMultiTransferTest(_L("DFC cb req before ISR cb req "), 1, transferArgArray, expected, ARRAY_LENGTH(transferArgArray))

				.SetPreTransferTest(&KPreTransferIncrBytes)

				.SetPostTransferTest(&KCompareSrcDst)

				.PauseWhileQueuing();

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

		}

	namespace IsrBeforeDfc

		{

		const TDmaTransferArgs transferArgArray[] = {

			isrTransfer,

			dfcTransfer

		};

		TResultSet isrSuccess = TResultSet(success).CallbackRecord(isrCallback);

		const TResultSet expected[] =

			{

			isrSuccess,

			queueFailure

			};

		CMultiTransferTest dfcBeforeIsr =

			CMultiTransferTest(_L("ISR cb req before DFC cb req "), 1, transferArgArray, expected, ARRAY_LENGTH(transferArgArray))

				.SetPreTransferTest(&KPreTransferIncrBytes)

				.SetPostTransferTest(&KCompareSrcDst)

				.PauseWhileQueuing();

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

		}

	}

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

//! TestCaseID      PBASE-DMA-FUNC-2587