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