kerneltest/e32test/dmav2/test_cases.cpp
changeset 8 538db54a451d
child 22 2f92ad2dc5db
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/dmav2/test_cases.cpp	Mon Jan 18 21:31:10 2010 +0200
@@ -0,0 +1,1352 @@
+/*
+* 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
+	The new API calls are used
+	*/
+	namespace CompareIsrDfcCb
+		{
+		const TInt iterations = 50;
+
+		namespace Dfc
+			{
+			TResultSet expected = TResultSet(threadCallback).
+				PostTransferResult(KErrUnknown);
+
+			namespace _4Bytes
+				{
+				const TInt size = 4;
+				TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr);
+				CDmaBmTransfer bmTest = CDmaBmTransfer(_L("4 bytes DFC cb"), iterations, transferArgs, 0).
+					UseNewDmaApi(ETrue).
+					ExpectedResults(expected);
+				TTestCase testCase(&bmTest, EFalse);
+				}
+			namespace _4K
+				{
+				const TInt size = 4 * KKilo;
+				TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr);
+				CDmaBmTransfer bmTest = CDmaBmTransfer(_L("4K DFC cb"), iterations, transferArgs, 0).
+					UseNewDmaApi(ETrue).
+					ExpectedResults(expected);
+				TTestCase testCase(&bmTest, EFalse);
+				}
+			}
+
+		namespace Isr
+			{
+			TResultSet expected = TResultSet(isrCallback).
+				PostTransferResult(KErrUnknown);
+
+			namespace _4Bytes
+				{
+				const TInt size = 4;
+				TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr);
+				CDmaBmTransfer bmTest = CDmaBmTransfer(_L("4 bytes Isr cb"), iterations, transferArgs, 0).
+					UseNewDmaApi(ETrue).
+					ExpectedResults(expected);
+				TTestCase testCase(&bmTest, EFalse);
+				}
+			namespace _4K
+				{
+				const TInt size = 4 * KKilo;
+				TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr);
+				CDmaBmTransfer bmTest = CDmaBmTransfer(_L("4K Isr cb"), iterations, transferArgs, 0).
+					UseNewDmaApi(ETrue).
+					ExpectedResults(expected);
+				TTestCase testCase(&bmTest, EFalse);
+				}
+			}
+		}
+	}
+
+//----------------------------------------------------------------------------------------------
+//! @SYMTestCaseID      KBASE-DMA-2560
+//! @SYMTestType        CIT
+//! @SYMPREQ            REQ
+//! @SYMTestCaseDesc    TestNewStyleFragment using CSingleTransferTest
+//!						Test Scenario 1 - DstAddr > SrcAddr & TransferSize=32K & Location is 
+//!						address of a memory buffer
+//! @SYMTestActions     
+//!						1.	Set up the arguments for aTransfeArgs using the settings below.
+//!							
+//!							SrcAddr		 = 4 * KKilo;
+//!							desAddr		 = 64 * KKilo;
+//!							transferSize = 32 * KKilo;	
+//!							iFlags		 = KDmaMemAddr;
+//!
+//!						2.	Setup expected result.
+//!						3.	Create single transfer test and run test
+//!
+//! @SYMTestExpectedResults 
+//!						1.  TransfeArgs set up in DMA framework
+//!						2.	Expected results set up in DMA framework					
+//!						3.	Fragment request completes and KErrNone returned
+//!
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+//----------------------------------------------------------------------------------------------
+namespace TestNewStyleFragment_1
+	{	
+	const TInt srcAddr = 4 * KKilo;
+	const TInt desAddr = 64 * KKilo;
+
+	const TInt transferSize =  32 * KKilo;
+	
+	TDmaTransferArgs transferArgs( srcAddr, desAddr, transferSize, KDmaMemAddr);
+
+	const TRequestResults requestResult(KErrNone, 32); 
+	const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback);
+
+	CSingleTransferTest testscenario_1(_L("TestNewStyleFragment - Test Scenario 1"), 1, transferArgs, expectedResults,KKilo);
+
+	TTestCase testCase(&testscenario_1, EFalse, capAboveV1);
+	TTestCase testCaseConcurrent(&testscenario_1, ETrue, capAboveV1);
+	}
+
+//----------------------------------------------------------------------------------------------
+//! @SYMTestCaseID      KBASE-DMA-2560
+//! @SYMTestType        CIT
+//! @SYMPREQ            REQ
+//! @SYMTestCaseDesc    TestNewStyleFragment using CSingleTransferTest
+//!						Test Scenario 2 -  SrcAddr	== DstAddr   					
+//!		
+//!						1.	Set up the arguments for aTransfeArgs using the settings below.
+//!							
+//!							SrcAddr	 = 4 * KKilo;
+//!							desAddr	 = 4 * KKilo;
+//!							transferSize = 32 * KKilo;	
+//!							iFlags		 = KDmaMemAddr;
+//!
+//!						2.	Setup expected result.
+//!						3.	Create single transfer test and run test
+//!
+//! @SYMTestExpectedResults 
+//!
+//!						1.  TransfeArgs set up in DMA framework
+//!						2.	Expected results set up in DMA framework					
+//!						3.	Fragment passes and KErrNone returned
+//!
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+//----------------------------------------------------------------------------------------------
+namespace TestNewStyleFragment_2
+	{
+	const TInt srcAddr = 4 * KKilo;
+	const TInt desAddr = 4 * KKilo;
+	const TInt transferSize =  32 * KKilo;
+
+	TDmaTransferArgs transferArgs(srcAddr,desAddr, transferSize, KDmaMemAddr);
+	const TRequestResults requestResult(KErrNone, 32); 
+	const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback);
+
+	CSingleTransferTest testscenario_2(_L("TestNewStyleFragment - Test Scenario 2"), 1, transferArgs, expectedResults,KKilo);
+
+	TTestCase testCase(&testscenario_2, EFalse, capAboveV1);
+	TTestCase testCaseConcurrent(&testscenario_2, ETrue, capAboveV1);
+	}
+
+//----------------------------------------------------------------------------------------------
+//! @SYMTestCaseID      KBASE-DMA-2560
+//! @SYMTestType        CIT
+//! @SYMPREQ            REQ
+//! @SYMTestCaseDesc    TestNewStyleFragment using CSingleTransferTest
+//!						Test Scenario 3 -  TransferSize=0   
+//!
+//!						1.	Set up the arguments for aTransfeArgs using the settings below.
+//!							
+//!							SrcAddr		 = 32 * KKilo;
+//!							desAddr		 = 64 * KKilo;
+//!							transferSize = 0	
+//!							iFlags		 = KDmaMemAddr;
+//!
+//!						2.	Setup expected result.
+//!						3.	Create single transfer test and run test
+//!
+//!
+//! @SYMTestExpectedResults 
+//!
+//!						1.  TransfeArgs set up in DMA framework
+//!						2.	Expected results set up in DMA framework			
+//!						3.	Fragment request fails and KErrArgument returned
+//!
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+//----------------------------------------------------------------------------------------------
+namespace TestNewStyleFragment_3
+	{
+	const TInt srcAddr = 32 * KKilo;
+	const TInt desAddr = 64 * KKilo;
+	const TInt transferSize = 0;
+	
+	TDmaTransferArgs transferArgs( srcAddr, desAddr, transferSize,KDmaMemAddr);
+	const TRequestResults requestResult(KErrArgument, 0); 
+	const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback);
+
+	CSingleTransferTest testscenario_3(_L("TestNewStyleFragment - Test Scenario 3"), 1, transferArgs, expectedResults);
+
+	TTestCase testCase(&testscenario_3, EFalse, capAboveV1);
+	TTestCase testCaseConcurrent(&testscenario_3, ETrue, capAboveV1);
+	}
+
+//----------------------------------------------------------------------------------------------
+//! @SYMTestCaseID      KBASE-DMA-2560
+//! @SYMTestType        CIT
+//! @SYMPREQ            REQ
+//! @SYMTestCaseDesc    TestNewStyleFragment using CSingleTransferTest
+//!						Test Scenario 4 -  TransferSize=1Byte   
+//!
+//!						1.	Set up the arguments for aTransfeArgs using the settings below.
+//!							
+//!							SrcAddr		 = 32K;
+//!							desAddr		 = 64K;
+//!							transferSize = 1 byte	
+//!							iFlags		 = KDmaMemAddr;
+//!
+//!						2.	Setup expected result.
+//!						3.	Create single transfer test and run test
+//!
+//! @SYMTestExpectedResults 
+//!
+//!						1.  TransfeArgs set up in DMA framework
+//!						2.	Expected results set up in DMA framework			
+//!						3.	Fragment request completes and KErrNone returned
+//!
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+//----------------------------------------------------------------------------------------------
+namespace TestNewStyleFragment_4
+	{	
+	const TInt srcAddr = 32 * KKilo;
+	const TInt desAddr = 64 * KKilo;
+	const TInt transferSize = 1;
+	
+	TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize, KDmaMemAddr);
+	const TRequestResults requestResult(KErrNone, 1);
+	const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback);
+
+	CSingleTransferTest testscenario_4(_L("TestNewStyleFragment - Test Scenario 4"), 1, transferArgs, expectedResults);
+
+	TTestCase testCase(&testscenario_4, EFalse, capAboveV1);
+	TTestCase testCaseConcurrent(&testscenario_4, ETrue, capAboveV1);
+	}
+
+//----------------------------------------------------------------------------------------------
+//! @SYMTestCaseID      KBASE-DMA-2560
+//! @SYMTestType        CIT
+//! @SYMPREQ            REQ
+//! @SYMTestCaseDesc    TestNewStyleFragment using CSingleTransferTest
+//!						Test Scenario 5 -  TransferSize=128KB    
+//!
+//!						1.	Set up the arguments for aTransfeArgs using the settings below.
+//!							
+//!							SrcAddr		 = 16K;
+//!							desAddr		 = 2MB;
+//!							transferSize = 1MB;
+//!							iFlags		 = KDmaMemAddr;
+//!
+//!						2.	Setup expected result.
+//!						3.	Create single transfer test and run test
+//!
+//! @SYMTestExpectedResults 
+//!
+//!						1.  TransfeArgs set up in DMA framework
+//!						2.	Expected results set up in DMA framework			
+//!						3.	Fragment request completes and KErrNone returned
+//!
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+//----------------------------------------------------------------------------------------------
+namespace TestNewStyleFragment_5
+	{
+	
+	const TInt srcAddr		= 16 * KKilo;
+	const TInt desAddr		= 2 * KMega;	
+	const TInt transferSize = 1 * KMega;
+
+	TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize, KDmaMemAddr);
+	const TRequestResults requestResult(KErrNone); 
+	const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback);
+
+	CSingleTransferTest testscenario_5(_L("TestNewStyleFragment - Test Scenario 5"), 1, transferArgs, expectedResults);
+
+	TTestCase testCase(&testscenario_5, EFalse, capAboveV1);
+	TTestCase testCaseConcurrent(&testscenario_5, ETrue, capAboveV1);
+	}
+
+//----------------------------------------------------------------------------------------------
+//! @SYMTestCaseID      KBASE-DMA-2560
+//! @SYMTestType        CIT
+//! @SYMPREQ            REQ
+//! @SYMTestCaseDesc    TestNewStyleFragment using CSingleTransferTest
+//!						Test Scenario 6 -  TransferSize=3MB   
+//!
+//!						1.	Set up the arguments for aTransfeArgs using the settings below.
+//!							
+//!							SrcAddr		 = 16K;
+//!							desAddr		 = 4MB;
+//!							transferSize = 3MB 	
+//!							iFlags		 = KDmaMemAddr;
+//!
+//!						2.	Setup expected result.
+//!						3.	Create single transfer test and run test
+//!
+//! @SYMTestExpectedResults 
+//!
+//!						1.  TransfeArgs set up in DMA framework
+//!						2.	Expected results set up in DMA framework			
+//!						3.	Fragment request completes and KErrNone returned
+//!
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+//----------------------------------------------------------------------------------------------
+namespace TestNewStyleFragment_6
+	{
+	const TInt srcAddr = 16 * KKilo;
+	const TInt desAddr = 4 * KMega;
+	const TInt transferSize = 3 * KMega;
+
+	TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize, KDmaMemAddr);
+	const TRequestResults requestResult(KErrNone); 
+	const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback);
+
+	CSingleTransferTest testscenario_6(_L("TestNewStyleFragment - Test Scenario 6"), 1, transferArgs, expectedResults);
+
+	TTestCase testCase(&testscenario_6, EFalse, capAboveV1);
+	TTestCase testCaseConcurrent(&testscenario_6, ETrue, capAboveV1);
+	}
+
+//----------------------------------------------------------------------------------------------
+//! @SYMTestCaseID      KBASE-DMA-2561
+//! @SYMTestType        CIT
+//! @SYMPREQ            REQ
+//! @SYMTestCaseDesc    TestOldstyleFragment using CSingleTransferTest
+//!						Test Scenario 1 - DstAddr > SrcAddr & TransferSize=32K & Location is 
+//!						address of a memory buffer
+//!
+//!						1.	Set up the arguments for aTransfeArgs using the settings below.
+//!							
+//!							SrcAddr		 = 4 * KKilo;
+//!							desAddr		 = 64 * KKilo;
+//!							transferSize = 32 * KKilo;	
+//!							iFlags		 = KDmaMemAddr;
+
+//!						2.	Setup expected result.
+//!						3.	Create single transfer test and run test
+//!
+//! @SYMTestExpectedResults 
+//!
+//!						1.  TransfeArgs set up in DMA framework
+//!						2.	Expected results set up in DMA framework					
+//!						3.	Fragment request completes and KErrNone returned
+//!
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+//----------------------------------------------------------------------------------------------
+namespace TestOldStyleFragment_1
+	{	
+	const TInt srcAddr = 4 * KKilo;
+	const TInt desAddr = 64 * KKilo;
+	const TInt transferSize =  32 * KKilo;
+	
+	TDmaTransferArgs transferArgs( srcAddr, desAddr, transferSize, KDmaMemAddr);
+
+	const TRequestResults requestResult(KErrNone,32); 
+	const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback);
+
+	CSingleTransferTest testscenario_1 = CSingleTransferTest(_L("TestOldStyleFragment - Test Scenario 1"), 1, transferArgs, expectedResults,KKilo).
+		UseNewDmaApi(EFalse);
+
+	TTestCase testCase(&testscenario_1, EFalse, capAboveV1);
+	TTestCase testCaseConcurrent(&testscenario_1, ETrue, capAboveV1);
+	}
+
+//----------------------------------------------------------------------------------------------
+//! @SYMTestCaseID      KBASE-DMA-2561
+//! @SYMTestType        CIT
+//! @SYMPREQ            REQ
+//! @SYMTestCaseDesc    TestOldstyleFragment using CSingleTransferTest
+//!						Test Scenario 2 - DstAddr == SrcAddr
+//!
+//!						1.	Set up the arguments for aTransfeArgs using the settings below.
+//!							
+//!							SrcAddr	 = 4 * KKilo;
+//!							desAddr	 = 4 * KKilo;
+//!							transferSize = 4 * KKilo
+//!							iFlags		 = KDmaMemAddr;
+//!
+//!						2.	Setup expected result.
+//!						3.	Create single transfer test and run test
+//!
+//! @SYMTestExpectedResults 
+//!
+//!						1.  TransfeArgs set up in DMA framework
+//!						2.	Expected results set up in DMA framework			
+//!						3.	Fragment passes and KErrNone returned
+//!
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+//----------------------------------------------------------------------------------------------
+namespace TestOldStyleFragment_2
+	{
+	const TInt srcAddr = 4 * KKilo;
+	const TInt desAddr = 4 * KKilo;
+	const TInt transferSize =  4 * KKilo;
+
+	TDmaTransferArgs transferArgs(srcAddr,desAddr, transferSize, KDmaMemAddr);
+	const TRequestResults requestResult(KErrNone, 4);  
+	const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback);
+
+	CSingleTransferTest testscenario_2 = CSingleTransferTest(_L("TestOldStyleFragment - Test Scenario 2"), 1, transferArgs, expectedResults,KKilo)
+		.UseNewDmaApi(EFalse);
+
+	TTestCase testCase(&testscenario_2, EFalse, capAboveV1);
+	TTestCase testCaseConcurrent(&testscenario_2, ETrue, capAboveV1);
+	}
+
+//----------------------------------------------------------------------------------------------
+//! @SYMTestCaseID      KBASE-DMA-2561
+//! @SYMTestType        CIT
+//! @SYMPREQ            REQ
+//! @SYMTestCaseDesc    TestOldstyleFragment using CSingleTransferTest
+//!						Test Scenario 3 -  TransferSize=0  
+//!
+//!						1.	Set up the arguments for aTransfeArgs using the settings below.
+//!							
+//!							SrcAddr	 = 32K
+//!							desAddr	 = 64K;
+//!							transferSize = 0
+//!							iFlags		 = KDmaMemAddr;
+//!
+//!						2.	Setup expected result.
+//!						3.	Create single transfer test and run test
+//!
+//! @SYMTestExpectedResults 
+//!
+//!						1.  TransfeArgs set up in DMA framework
+//!						2.	Expected results set up in DMA framework			
+//!						3.	Fragment request Fails and KErrArgument returned
+//!
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+//----------------------------------------------------------------------------------------------
+namespace TestOldStyleFragment_3
+	{
+
+	const TInt srcAddr = 32 * KKilo;
+	const TInt desAddr = 64 * KKilo;
+	const TInt transferSize = 0;
+	
+	TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize,KDmaMemAddr);
+	const TRequestResults requestResult(KErrArgument, 0); 
+	const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback);
+
+	CSingleTransferTest testscenario_3 = CSingleTransferTest(_L("TestOldStyleFragment - Test Scenario 3"), 1, transferArgs, expectedResults).
+		UseNewDmaApi(EFalse);
+
+	TTestCase testCase(&testscenario_3, EFalse, capAboveV1);
+	TTestCase testCaseConcurrent(&testscenario_3, ETrue, capAboveV1);
+	}
+
+//----------------------------------------------------------------------------------------------
+//! @SYMTestCaseID      KBASE-DMA-2561
+//! @SYMTestType        CIT
+//! @SYMPREQ            REQ
+//! @SYMTestCaseDesc    TestOldstyleFragment using CSingleTransferTest
+//!						Test Scenario 4 -  TransferSize=1Byte   
+//!
+//!						1.	Set up the arguments for aTransfeArgs using the settings below.
+//!							
+//!	
+//!							SrcAddr		 = 32K;
+//!							desAddr		 = 64K;
+//!							transferSize = 1 byte	
+//!							iFlags		 = KDmaMemAddr;
+//!
+//!						2.	Setup expected result.
+//!						3.	Create single transfer test and run test
+//!
+//! @SYMTestExpectedResults 
+//!
+//!						1.  TransfeArgs set up in DMA framework
+//!						2.	Expected results set up in DMA framework			
+//!						3.	Fragment request completes and KErrNone returned
+//!
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+//------------------------------------------------------------------------------------------------
+namespace TestOldStyleFragment_4
+	{	
+	const TInt srcAddr = 32 * KKilo;
+	const TInt desAddr = 64 * KKilo;
+	const TInt transferSize = 1;
+	
+	TDmaTransferArgs transferArgs( srcAddr, desAddr, transferSize, KDmaMemAddr);
+	const TRequestResults requestResult(KErrNone, 1); 
+	const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback);
+
+	CSingleTransferTest testscenario_4 = CSingleTransferTest(_L("TestOldStyleFragment - Test Scenario 4"), 1, transferArgs, expectedResults).
+		UseNewDmaApi(EFalse);
+
+	TTestCase testCase(&testscenario_4, EFalse, capAboveV1);
+	TTestCase testCaseConcurrent(&testscenario_4, ETrue, capAboveV1);
+	}
+
+//----------------------------------------------------------------------------------------------
+//! @SYMTestCaseID      KBASE-DMA-2561
+//! @SYMTestType        CIT
+//! @SYMPREQ            REQ
+//! @SYMTestCaseDesc    TestOldstyleFragment using CSingleTransferTest
+//!						Test Scenario 5 -  TransferSize=1MB
+//!
+//!						1.	Set up the arguments for aTransfeArgs using the settings below.
+//!							
+//!							SrcAddr		 = 16K;
+//!							desAddr		 = 2MB;
+//!							transferSize = 1MB	
+//!							iFlags		 = KDmaMemAddr;
+//!
+//!						2.	Setup expected result.
+//!						3.	Create single transfer test and run test
+//!
+//! @SYMTestExpectedResults 
+//!
+//!						1.  TransfeArgs set up in DMA framework
+//!						2.	Expected results set up in DMA framework			
+//!						3.	Fragment request completes and KErrNone returned
+//!
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+//----------------------------------------------------------------------------------------------
+namespace TestOldStyleFragment_5
+	{
+	const TInt srcAddr = 16 * KKilo;	
+	const TInt desAddr = 2 * KMega;
+	const TInt transferSize = 1 *  KMega;
+
+	TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize, KDmaMemAddr);
+
+	const TRequestResults requestResult(KErrNone); 
+	const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback);
+
+	CSingleTransferTest testscenario_5 = CSingleTransferTest(_L("TestOldStyleFragment - Test Scenario 5"), 1, transferArgs, expectedResults).
+		UseNewDmaApi(EFalse);
+
+	TTestCase testCase(&testscenario_5, EFalse, capAboveV1);
+	TTestCase testCaseConcurrent(&testscenario_5, ETrue, capAboveV1);
+	}
+
+//----------------------------------------------------------------------------------------------
+//! @SYMTestCaseID      KBASE-DMA-2561
+//! @SYMTestType        CIT
+//! @SYMPREQ            REQ
+//! @SYMTestCaseDesc    TestOldstyleFragment using CSingleTransferTest
+//!						Test Scenario 6 -  TransferSize=3MB     
+//!
+//!						1.	Set up the arguments for aTransfeArgs using the settings below.
+//!							
+//!							SrcAddr	 = 16K
+//!							desAddr	 = 4MB;
+//!							transferSize = 3MB  
+//!							iFlags		 = KDmaMemAddr;
+//!
+//!						2.	Setup expected result.
+//!						3.	Create single transfer test and run test
+//!
+//! @SYMTestExpectedResults 
+//!
+//!						1.  TransfeArgs set up in DMA framework
+//!						2.	Expected results set up in DMA framework			
+//!						3.	Fragment request completes and KErrNone returned
+//!
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+//----------------------------------------------------------------------------------------------
+namespace TestOldStyleFragment_6
+	{
+	const TInt srcAddr = 16 * KKilo;
+	const TInt desAddr = 4 * KMega;
+	const TInt transferSize = 3 * KMega; 
+	TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize, KDmaMemAddr);
+
+	const TRequestResults requestResult(KErrNone); 
+	const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback);
+
+	CSingleTransferTest testscenario_6 = CSingleTransferTest(_L("TestOldStyleFragment - Test Scenario 6"), 1, transferArgs, expectedResults).
+		UseNewDmaApi(EFalse);
+
+	TTestCase testCase(&testscenario_6, EFalse, capAboveV1);
+	TTestCase testCaseConcurrent(&testscenario_6, ETrue, capAboveV1);
+	}
+
+//----------------------------------------------------------------------------------------------
+//! @SYMTestCaseID      KBASE-DMA-2562
+//! @SYMTestType        CIT
+//! @SYMPREQ            REQ
+//! @SYMTestCaseDesc    TestOldStyleDDmaRequest using CSingleTransferTest
+//!						Test Scenario 1 -  aMaxTransferSize=0 
+//!
+//!						1.	Set up the DDmaRequest using  aMaxTransferSize set to 0. 
+//!						2.	Setup expected result.
+//!						3.	Create single transfer test and run test
+//!
+//! @SYMTestExpectedResults 
+//!
+//!						1.  TransfeArgs set up in DMA framework
+//!						2.	Expected results set up in DMA framework			
+//!						3.	DDmaRequest constructor behaves as expected and KErrArgument returned
+//!
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+//------------------------------------------------------------------------------------------------
+namespace TestOldStyleDDmaRequest_1
+	{
+	const TInt desAddr = 4 * KKilo;
+	const TInt transferSize = 4 * KKilo;
+	TDmaTransferArgs transferArgs(0, desAddr, transferSize, KDmaMemAddr);
+
+	const TRequestResults requestResult(KErrNone, 0); 
+	const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback);
+
+	CSingleTransferTest testscenario_1 = CSingleTransferTest(_L("TestOldStyleDDmaRequest - Test Scenario 1"), 1, transferArgs, expectedResults,0).
+		UseNewDmaApi(EFalse);
+
+	TTestCase testCase(&testscenario_1, EFalse, capAboveV1);
+	TTestCase testCaseConcurrent(&testscenario_1, ETrue, capAboveV1);
+	}
+
+//!-------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID       KBASE-DMA-2562
+//! @SYMTestType        CIT
+//! @SYMPREQ            REQ
+//! @SYMTestCaseDesc    TestOldStyleDDmaRequest using CSingleTransferTest
+//!						Test Scenario 2 -  aMaxTransferSize= 65535   
+//!
+//!						1.	Set up the arguments for DDmaRequest using aMaxTransferSize set to 65535.
+//!						2.	Setup expected result.
+//!						3.	Create single transfer test and run test
+//!
+//! @SYMTestExpectedResults 
+//!
+//!						1.  TransfeArgs set up in DMA framework
+//!						2.	Expected results set up in DMA framework			
+//!						3.	DDmaRequest constructor behaves as expected and KErrArgument returned
+//!
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+//---------------------------------------------------------------------------------------------------
+namespace TestOldStyleDDmaRequest_2
+	{
+	const TInt desAddr = 4 * KKilo;
+	const TInt transferSize = 4 * KKilo;
+	TDmaTransferArgs transferArgs(0, desAddr, transferSize, KDmaMemAddr);
+
+	const TRequestResults requestResult(KErrNone, 1); 
+	const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback);
+
+	CSingleTransferTest testscenario_2 = CSingleTransferTest(_L("TestOldStyleDDmaRequest - Test Scenario 2"), 1, transferArgs, expectedResults, 65535).
+		UseNewDmaApi(EFalse);
+
+	TTestCase testCase(&testscenario_2, EFalse, capAboveV1);
+	TTestCase testCaseConcurrent(&testscenario_2, ETrue, capAboveV1);
+	}
+
+//----------------------------------------------------------------------------------------------
+//! @SYMTestCaseID      KBASE-DMA-2563
+//! @SYMTestType        CIT
+//! @SYMPREQ            REQ
+//! @SYMTestCaseDesc    TestNewStyleDDmaRequest using CSingleTransferTest
+//!						Test Scenario 1 -  aMaxTransferSize=0 
+//!
+//!						1.	Set up the DDmaRequest using  aMaxTransferSize set to 0. 
+//!						2.	Setup expected result.
+//!						3.	Create single transfer test and run test
+//!
+//! @SYMTestExpectedResults 
+//!
+//!						1.  TransfeArgs set up in DMA framework
+//!						2.	Expected results set up in DMA framework			
+//!						3.	DDmaRequest constructor behaves as expected and KErrArgument returned
+//!
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+//----------------------------------------------------------------------------------------------
+namespace TestNewStyleDDmaRequest_1
+	{
+	const TInt desAddr = 4 * KKilo;
+	const TInt transferSize = 4 * KKilo;
+	TDmaTransferArgs transferArgs(0, desAddr, transferSize, KDmaMemAddr);
+
+	const TRequestResults requestResult(KErrNone, 0); 
+	const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback);
+
+	CSingleTransferTest testscenario_1(_L("TestNewStyleDDmaRequest - Test Scenario 1"), 1, transferArgs, expectedResults,0);
+
+	TTestCase testCase(&testscenario_1, EFalse, capAboveV1);
+	TTestCase testCaseConcurrent(&testscenario_1, ETrue, capAboveV1);
+	}
+
+//!-------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID      KBASE-DMA-2563
+//! @SYMTestType        CIT
+//! @SYMPREQ            REQ
+//! @SYMTestCaseDesc    TestNewStyleDDmaRequest using CSingleTransferTest
+//!						Test Scenario 2 -  aMaxTransferSize= 65535   
+//!
+//!						1.	Set up the arguments for DDmaRequest using aMaxTransferSize set to 65535.
+//!						2.	Setup expected result.
+//!						3.	Create single transfer test and run test
+//!
+//! @SYMTestExpectedResults 
+//!
+//!						1.  TransfeArgs set up in DMA framework
+//!						2.	Expected results set up in DMA framework			
+//!						3.	DDmaRequest constructor behaves as expected and KErrArgument returned
+//!
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+//---------------------------------------------------------------------------------------------------
+namespace TestNewStyleDDmaRequest_2
+	{
+	const TInt desAddr = 4 * KKilo;
+	const TInt transferSize = 4 * KKilo;
+	TDmaTransferArgs transferArgs(0, desAddr, transferSize, KDmaMemAddr);
+
+	const TRequestResults requestResult(KErrNone, 1); 
+	const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback);
+
+	CSingleTransferTest testscenario_2(_L("TestNewStyleDDmaRequest - Test Scenario 2"), 1, transferArgs, expectedResults, 65535);
+
+	TTestCase testCase(&testscenario_2, EFalse, capAboveV1);
+	TTestCase testCaseConcurrent(&testscenario_2, ETrue, capAboveV1);
+	}
+
+//----------------------------------------------------------------------------------------------
+//! @SYMTestCaseID      PBASE-DMA-FUNC-xxx
+//! @SYMTestType        CIT
+//! @SYMPREQ            REQ
+//! @SYMTestCaseDesc    SmallFrags: This test provokes the failure seen in DEF140598
+//!						The test checks that requests with small fragments
+//!						do not trigger a spurious missed interrupt clean up
+//!
+//! @SYMTestExpectedResults 
+//!
+//!						1.  		
+//!						2.	
+//!
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+//----------------------------------------------------------------------------------------------
+namespace SmallFrags
+	{
+	const TInt size = 32;
+	TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr);
+
+	const TResultSet expectedResults(threadCallback);
+
+	TTestCase testCase(
+			new (ELeave) CSingleTransferTest(_L("8 * 4byte frags"), 10, transferArgs, expectedResults, 4),
+			EFalse, capAboveV1);
+	}
+
+
+//TODO TTestCase could automatically be added to aray by ctor
+//
+//Append new test cases here
+static TTestCase* StaticTestArray[] = {
+	&Simple_1::testCase,
+	&Simple_1::testCaseConcurrent,
+	&Simple_2::testCase,
+	&Simple_2::testCaseConcurrent,
+	&Callback::testCase,
+	&Callback::testCaseOldRequest,
+	&ISR_Reque::endOnRedo::testCase,
+	&ISR_Reque::endOnIsrCb::testCase,
+	&ISR_Reque::endOnThreadCb::testCase,
+	&ISR_Reque::changeSize::testCase,
+#ifdef _DEBUG
+	&ISR_Reque::invalidAddresses::testCase, // addresses only checked in UDEB
+#endif
+	//&ISR_Reque::multipleFragments::testCase, // This error condition is currently caught by a FAULT instead of a return code
+	&Multipart::testCase,
+	&IsrAndDfc::DfcBeforeIsr::testCase,
+	&IsrAndDfc::IsrBeforeDfc::testCase,
+	&_2D_Test::testCase2d,
+	&FragmentationCount::testCase,
+	&FragmentationCount::testCase2,
+	&SmallFrags::testCase,
+#ifndef _DEBUG
+	// Benchmarks are only really meaningful
+	// on UREL builds
+	&Benchmark::Frag::testCase_256k,
+	&Benchmark::Frag::testCase_8k,
+	&Benchmark::Transfer::_128K::testCase_128,
+	&Benchmark::Transfer::_128K::testCase_16,
+	&Benchmark::Transfer::_128K::testCase_4,
+	&Benchmark::Transfer::_128K::testCase_1,
+	&Benchmark::Transfer::_4Bytes::testCase,
+	&Benchmark::Transfer::_4Mb::testCase,
+	&Benchmark::CompareIsrDfcCb::Dfc::_4Bytes::testCase,
+	&Benchmark::CompareIsrDfcCb::Isr::_4Bytes::testCase,
+	&Benchmark::CompareIsrDfcCb::Dfc::_4K::testCase,
+	&Benchmark::CompareIsrDfcCb::Isr::_4K::testCase,
+#endif
+	&TestNewStyleFragment_1::testCase,
+	&TestNewStyleFragment_1::testCaseConcurrent,
+	&TestNewStyleFragment_2::testCase,
+	&TestNewStyleFragment_2::testCaseConcurrent,
+	//&TestNewStyleFragment_3::testCase,
+	//&TestNewStyleFragment_3::testCaseConcurrent,
+	&TestNewStyleFragment_4::testCase,
+	&TestNewStyleFragment_4::testCaseConcurrent,
+	&TestNewStyleFragment_5::testCase,
+	&TestNewStyleFragment_5::testCaseConcurrent,
+	&TestNewStyleFragment_6::testCase,
+	&TestNewStyleFragment_6::testCaseConcurrent,
+	&TestOldStyleFragment_1::testCase,
+	&TestOldStyleFragment_1::testCaseConcurrent,
+	&TestOldStyleFragment_2::testCase,
+	&TestOldStyleFragment_2::testCaseConcurrent,
+	//&TestOldStyleFragment_3::testCase,
+	//&TestOldStyleFragment_3::testCaseConcurrent,
+	&TestOldStyleFragment_4::testCase,
+	&TestOldStyleFragment_4::testCaseConcurrent,
+	&TestOldStyleFragment_5::testCase,
+	&TestOldStyleFragment_5::testCaseConcurrent,
+	&TestOldStyleFragment_6::testCase,
+	&TestOldStyleFragment_6::testCaseConcurrent,
+	&TestOldStyleDDmaRequest_1::testCase,
+	&TestOldStyleDDmaRequest_1::testCaseConcurrent,
+	&TestOldStyleDDmaRequest_2::testCase,
+	&TestOldStyleDDmaRequest_2::testCaseConcurrent,
+	&TestNewStyleDDmaRequest_1::testCase,
+	&TestNewStyleDDmaRequest_1::testCaseConcurrent,
+	&TestNewStyleDDmaRequest_2::testCase,
+	&TestNewStyleDDmaRequest_2::testCaseConcurrent,
+};
+
+RPointerArray<TTestCase> TestArray(StaticTestArray, ARRAY_LENGTH(StaticTestArray));