/*

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

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

//! @SYMTestCaseID      KBASE-DMA-2560

//! @SYMTestType        CIT

//! @SYMPREQ            REQ

//! @SYMTestCaseDesc    Simple DMA transfer test using CSingleTransferTest and New DMA APIs

//!

//! @SYMTestActions     

//!						1.

//!						2.	

//!

//!

//! @SYMTestExpectedResults 

//!						1.  

//!						2.		

//!							

//!

//! @SYMTestPriority        High

//! @SYMTestStatus          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(&simpleTest, EFalse, capAboveV1);

	TTestCase testCaseConcurrent(&simpleTest, ETrue, capAboveV1);

	}

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

//! @SYMTestCaseID      KBASE-DMA-2561

//! @SYMTestType        CIT

//! @SYMPREQ            REQ

//! @SYMTestCaseDesc    Simple DMA transfer test using CSingleTransferTest and OLD DMA APIs

//!

//! @SYMTestActions     

//!						1.

//!						2.	

//!

//!

//! @SYMTestExpectedResults 

//!						1.  

//!						2.						

//!							

//!

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

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

namespace Simple_2

	{

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

	const TResultSet expectedResults(threadCallback);

	CSingleTransferTest simpleTest = CSingleTransferTest(_L("Simple Test - Old DMA APIs"), 1, transferArgs, expectedResults, 0).

		UseNewDmaApi(EFalse);

	TTestCase testCase(&simpleTest, EFalse);

	TTestCase testCaseConcurrent(&simpleTest, ETrue);

	}

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

//! @SYMTestCaseID      KBASE-DMA-2573

//! @SYMTestType        CIT

//! @SYMPREQ            REQ

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

//!

//! @SYMTestActions     

//!						1.

//!						2.	

//!

//!

//! @SYMTestExpectedResults 

//!						1.  

//!						2.		

//!							

//!

//! @SYMTestPriority        High

//! @SYMTestStatus          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);

	}

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

//! @SYMTestCaseID      KBASE-DMA-2574,KBASE-DMA-2575

//! @SYMTestType        CIT

//! @SYMPREQ            REQ

//! @SYMTestCaseDesc    DMA ISR Reque test

//!

//! @SYMTestActions     

//!						1.

//!						2.	

//!

//!

//! @SYMTestExpectedResults 

//!						1.  

//!						2.		

//!							

//!

//! @SYMTestPriority        High

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

	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);

		}

	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);

		}

	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);

		}

	namespace endOnRedo

		{

		// TODO have made this bigger than 4k so that we don't miss the second interrupt when tracing enabled

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

		}

	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);

		}

	namespace multipleFragments

		{

		TIsrRequeArgs requeArgs[] = {

			TIsrRequeArgs()

		};

		const TInt count = ARRAY_LENGTH(requeArgs);

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

		TRequestResults results2Fragments = TRequestResults(requestResult).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);

		}

	}

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

//! @SYMTestCaseID      PBASE-DMA-FUNC-xxx

//! @SYMTestType        CIT

//! @SYMPREQ            REQ

//! @SYMTestCaseDesc    DMA Multiple transfer test

//! @SYMTestActions     

//!						1.

//!						2.	

//!

//!

//! @SYMTestExpectedResults 

//!						1.  

//!						2.		

//!							

//!

//! @SYMTestPriority        High

//! @SYMTestStatus          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(size, 2 * size, size, KDmaMemAddr)

	};

	const TResultSet expected[] =

		{

		TResultSet(),

		TResultSet()

		};

	const TResultSet expectedResults(isrCallback);

	CMultiTransferTest multipart =

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

			.SetPreTransferTest(&KPreTransferIncrBytes)

			.SetPostTransferTest(&KCompareSrcDst);

	TTestCase testCase(&multipart, EFalse, hwDesWanted_skip);

	}

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

//! @SYMTestCaseID      KBASE-DMA-2580

//! @SYMTestType        CIT

//! @SYMPREQ            REQ

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

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

//! @SYMTestActions     

//!						1.

//!						2.	

//!

//!

//! @SYMTestExpectedResults 

//!						1.  

//!						2.		

//!							

//!

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

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

namespace IsrAndDfc

	{

	// need long transfer, so that 1st request is still queued

	// when the second one is queued

	// TODO pause is the better way to ensure this

	//const TInt size = 2 * KMega;

	//TODO have changed size 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(size, 2 * 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);

		TTestCase testCase(&dfcBeforeIsr, EFalse, hwDesWanted_skip);

		}

	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);

		TTestCase testCase(&dfcBeforeIsr, EFalse, hwDesWanted_skip);

		}

	}

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

//! @SYMTestCaseID      PBASE-DMA-FUNC-xxx

//! @SYMTestType        CIT

//! @SYMPREQ            REQ

//! @SYMTestCaseDesc    DMA 2D transfer test

//!

//! @SYMTestActions     

//!						1.

//!						2.	

//!

//!

//! @SYMTestExpectedResults 

//!						1.  

//!						2.		

//!							

//!

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

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

namespace _2D_Test

	{

	// Image @ 0x0 with 640x480 pixels and 24 bits/pixel.

	TDmaTransferConfig src(

		0, /*iAddr*/

		3, /*iElementSize*/

		6, /*iElementsPerFrame*/

		4, /*iFramesPerTransfer*/

		0, /*iElementSkip*/

		0, /*iFrameSkip*/

		KDmaMemAddr /*iFlags*/

		);

	TDmaTransferConfig dst(

		0x708000, /*iAddr*/

		3, /*iElementSize*/

		640, /*iElementsPerFrame*/

		480, /*iFramesPerTransfer*/

		1437, /*iElementSkip*/

		-920166, /*iFrameSkip*/

		KDmaMemAddr /*iFlags*/

		);

	TDmaTransferArgs transferArgs2D(src, dst);

	TResultSet expectedResults; //all KErrNone

	//source buffer is currently filled with increasing values

	//instead of an image, but the test is still valid

	CSingleTransferTest transfer2d(_L("2D Transfer"), 1, transferArgs2D, expectedResults, 0, &KCompare2D);

	TTestCase testCase2d(&transfer2d, EFalse, cap_2DRequired, capAboveV1);

	}

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

//! @SYMTestCaseID      KBASE-DMA-2565

//! @SYMTestType        CIT

//! @SYMPREQ            REQ

//! @SYMTestCaseDesc    DMA Fragmentation count test

//!

//! @SYMTestActions     

//!						1.

//!						2.	

//!

//!

//! @SYMTestExpectedResults 

//!						1.  

//!						2.		

//!							

//!

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

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

namespace FragmentationCount

	{

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

	const TRequestResults requestResult(KErrNone, 128);

	const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback);

	CSingleTransferTest test1(_L("Fragmentation Count - 128 fragments"), 1, transferArgs, expectedResults, KKilo);

	TTestCase testCase(&test1, EFalse);

	const TRequestResults requestResult2(KErrNone, 4);

	const TResultSet expectedResults2(KErrNone, requestResult2, KErrNone, threadCallback);

	CSingleTransferTest test2(_L("Fragmentation Count - 4 fragments"), 1, transferArgs, expectedResults2, 32*KKilo);

	TTestCase testCase2(&test2, EFalse);

	}

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

//! @SYMTestCaseID      KBASE-DMA-2584,KBASE-DMA-2585

//! @SYMTestType        CIT

//! @SYMPREQ            REQ

//! @SYMTestCaseDesc    DMA Benchmark tests

//!

//! @SYMTestActions     

//!						1.

//!						2.	

//!

//!

//! @SYMTestExpectedResults 

//!						1.  

//!						2.		

//!							

//!

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

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

namespace Benchmark

	{

	const TInt bmIters = 10;

	namespace Frag

		{

		const TInt size = 1 * KMega;

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

		TTestCase testCase_256k(new (ELeave) CDmaBmFragmentation(_L("1 Mb transfer - 256k frag size"), bmIters, transferArgs, 256 * KKilo), EFalse);

		TTestCase testCase_8k(new (ELeave) CDmaBmFragmentation(_L("1 Mb transfer - 8k frag size"), bmIters, transferArgs, 8 * KKilo), EFalse);

		}

	namespace Transfer

		{

		namespace _4Bytes

			{

			const TInt size = 4;

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

			CDmaBmTransfer bmTest(_L("4 bytes"), bmIters, transferArgs, 0);

			TTestCase testCase(&bmTest, EFalse);

			}

		namespace _128K

			{

			const TInt size = 128 * KKilo;

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

			TTestCase testCase_128(new (ELeave) CDmaBmTransfer(_L("128 K - 128K frag size"), bmIters, transferArgs, 128 * KKilo), EFalse);

			TTestCase testCase_16(new (ELeave) CDmaBmTransfer(_L("128 K - 16k frag size"), bmIters, transferArgs, 16 * KKilo), EFalse);

			TTestCase testCase_4(new (ELeave) CDmaBmTransfer(_L("128 K - 4k frag size"), bmIters, transferArgs, 4 * KKilo), EFalse);

			TTestCase testCase_1(new (ELeave) CDmaBmTransfer(_L("128 K - 1k frag size"), bmIters, transferArgs, 1 * KKilo), EFalse);

			}

		namespace _4Mb

			{

			const TInt size = 4 * KMega;

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

			CDmaBmTransfer bmTest(_L("4 Mb"), bmIters, transferArgs, 0);

			TTestCase testCase(&bmTest, EFalse);

			}

		}

	/**

	Compare time taken between queing and callback of 4 byte

	request with both DFC and ISR callback