--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/dmav2/test_cases.cpp Tue Aug 31 16:34:26 2010 +0300
@@ -0,0 +1,1393 @@
+/*
+* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+* This file contains statically defined test cases, a pointer to each
+* new test case should be entered in StaticTestArray
+*
+*/
+
+#include "t_dma2.h"
+#include "cap_reqs.h"
+
+const TCallbackRecord threadCallback(TCallbackRecord::EThread,1);
+const TCallbackRecord isrCallback(TCallbackRecord::EIsr,1);
+
+const TInt size = 128 * KKilo;
+const TInt trans64K_1 = ((64 * KKilo) -1); // 65535
+
+//----------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2571
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc This test verifies the correct behavior of CancelAll API in the new DMA
+//! framework
+//!
+//! TestActions
+//! 1. Open a DMA channel for a transfer.
+//! 2. Queue multiple request on the DMA channel.
+//! 3. Call CancelAll () on the DMA channel.
+//! 4. Verify that all transfers have been cancelled.
+//! 5 Open a DMA channel for a transfer. This channel should support pause and resume.
+//! 6. Call Pause () on the channel.
+//! 7. Queue multiple request on the DMA channel.
+//! 8. Call CancelAll () on the channel.
+//! 9. Verify that all transfers have been cancelled.
+//!
+//!
+//! TestExpectedResults 1. DMA channel opens and KErrNone returned.
+//! 2. DMA queue request created and KErrNone returned.
+//! 3. CancelAll () cancels all queued request.
+//! 4. All queued request are cancelled
+//! 5. DMA Request completes
+//!
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace CancelAllTest
+ {
+ const TInt size = 2 * KMega;
+ const TDmaTransferArgs transferArgArray[] = {
+ TDmaTransferArgs(0, size, size, KDmaMemAddr),
+ TDmaTransferArgs(2 * size, 3 * size, size, KDmaMemAddr)
+ };
+
+ TResultSet noTransferExpected = TResultSet()
+ .PostTransferResult(KErrNone)
+ .CallbackRecord(TCallbackRecord::Empty());
+
+ const TResultSet expected[] =
+ {
+ TResultSet(noTransferExpected),
+ TResultSet(noTransferExpected)
+ };
+
+ // Test that 2 requests can be queued on a paused channel
+ // then cleared using CancelAll.
+ // It is expected that no data will have been transferred to the
+ // destination buffer.
+ CCancelAllTest testcancelall =
+ CCancelAllTest(_L("CancelAllTest : Cancel and verify cancellation of requests"), 1, transferArgArray, expected, ARRAY_LENGTH(transferArgArray))
+ .SetPreTransferTest(&KPreTransferIncrBytes)
+ .SetPostTransferTest(&KCheckNoTransfer);
+
+ TTestCase testCase(&testcancelall,EFalse,capAboveV1,pauseRequired_skip);
+ }
+
+//--------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2569
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc This test verifies the correct behavior of Pause and Resume API in the new DMA
+//! framework
+//!
+//! TestActions
+//! 1. Open a DMA channel for a transfer.
+//! 2. Setup a DMA request and time how long the transfer takes
+//! 3. Pause the DMA channel
+//! 4. Repeat DMA transfer (queued asynchronously)
+//! 5. Resume DMA Channel
+//!
+//! TestExpectedResults 1. DMA channel opens and KErrNone returned.
+//! 2. DMA request created and KErrNone returned.
+//! 3. DMA channel Paused.
+//! 4. Request queued and waits until Resume is called
+//! 5. DMA Request completes
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace PauseResumeApiTest
+ {
+ const TInt srcAddr = 0;
+ const TInt desAddr = 2 * KMega;
+ const TInt transferSize = 1 * KMega;
+
+ TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize, KDmaMemAddr);
+ const TResultSet expectedResults(threadCallback);
+ CPauseResumeTest testPauseResume = CPauseResumeTest(_L("Pause and Resume Test"), 1, transferArgs, expectedResults);
+ TTestCase testCasePauseResume(&testPauseResume, EFalse, capAboveV1,pauseRequired_skip);
+ }
+//--------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2572
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc This test verifies the correct behavior of Pause and Resume API in the new DMA
+//! framework
+//!
+//! TestActions
+//! 1. Open a DMA channel for a transfer.
+//! 2. Pause and Resume DMA channel.
+//! 3. Close DMA channel.
+//!
+//!
+//! TestExpectedResults 1. DMA channel opens and KErrNone returned.
+//! 2. KErrNotSupported returned when Pause and Resume API are called.
+//! 3. DMA channel closes and KErrNone returned.
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace PauseResumeApiNegTest
+ {
+ const TInt srcAddr = 0;
+ const TInt desAddr = 2 * KMega;
+ const TInt transferSize = 1 * KMega;
+
+ TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize, KDmaMemAddr);
+
+ TResultSet noTransferExpected = TResultSet().
+ RequestResult(TRequestResults().CreationResult(KErrUnknown).FragmentationResult(KErrUnknown).QueueResult(KErrUnknown)).
+ CallbackRecord(TCallbackRecord::Empty()).
+ PostTransferResult(KErrUnknown);
+
+ CPauseResumeNegTest testPauseResumeNeg = CPauseResumeNegTest(_L("Pause and Resume Negative Test"), 1, transferArgs, noTransferExpected);
+ TTestCase testCasePauseResumeNeg(&testPauseResumeNeg , EFalse, capAboveV1,pauseNotWanted);
+ }
+//--------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2560
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc Simple DMA transfer test using CSingleTransferTest and New DMA APIs
+//!
+//! TestActions
+//! 1. Open a DMA channel for a transfer.
+//! 2. Create single transfer test and run test
+//!
+//!
+//!
+//! TestExpectedResults
+//! 1. DMA channel opens and KErrNone returned.
+//! 2. DMA transfer completes with no errors.
+//!
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace Simple_1
+ {
+ TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr);
+
+ const TResultSet expectedResults(threadCallback);
+
+ CSingleTransferTest simpleTest(_L("Simple Test - New DMA APIs"), 1, transferArgs, expectedResults);
+
+ TTestCase testCase(new (ELeave) CMultiVersionTest(&simpleTest), EFalse);
+ TTestCase testCaseConcurrent(new (ELeave) CMultiVersionTest(&simpleTest), ETrue);
+ }
+
+//----------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2573
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc DMA ISR Callback test (Isr Callback - use old request Ctor)
+//!
+//! TestActions
+//! 1. Setup DMA transfer to request a callback from ISR using old style DDmaRequest.
+//! 2. Create single transfer test and run test
+//! 3. Verify that DDmaRequest request fails
+//!
+//! TestExpectedResults
+//! 1. DMA channel opens and KErrNone returned.
+//! 2. DMA transfer created with no errors.
+//! 3. DDmaRequest request fails.
+//!
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace Callback
+ {
+ TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr);
+
+ const TResultSet expectedResults(isrCallback);
+
+ CSingleTransferTest isrTest(_L("Isr Callback"), 1, transferArgs, expectedResults);
+ TTestCase testCase(&isrTest, EFalse, capAboveV1);
+
+
+ const TRequestResults fragmentFails = TRequestResults().
+ FragmentationResult(KErrArgument).
+ QueueResult(KErrUnknown);
+
+ const TResultSet expectedResultsFail = TResultSet(EFalse).
+ ChannelOpenResult(KErrNone).
+ RequestResult(fragmentFails).
+ PostTransferResult(1); // PostTransferResult of 1 means buffers don't match
+
+ CSingleTransferTest isrTestOldRequest = CSingleTransferTest(_L("Isr Callback - use old request Ctor"), 1, transferArgs, expectedResultsFail)
+ .UseNewRequest(EFalse);
+ TTestCase testCaseOldRequest(&isrTestOldRequest, EFalse, capAboveV1);
+ }
+
+//----------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2574,KBASE-DMA-2575
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc DMA ISR Reque test
+//!
+//! TestActions
+//! 1. Setup DMA transfer to request a callback from ISR.
+//! 2. Set up ISR to requeue the DMA request on the same channel and adjust its transfer parameters.
+//! 3. Create single transfer test and run test
+//! 4. Verify a client can queue the just completed DMA request from within an ISR callback.
+//!
+//! TestExpectedResults
+//!
+//! DMA transfer completes and just completed request can be requeued from within an ISR
+//! callback on the same channel. Requeued DMA request completes successfully
+//!
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace ISR_Reque
+ {
+ const TInt size = 4 * KKilo;
+ TDmaTransferArgs tferArgs(0, 2*size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr);
+
+ const TRequestResults requestResult(KErrNone, 1); // request must be in a single fragment
+
+ //-------------------------------------------------------------
+ //This case requeues 4 transfers at the end of an ISR callback
+ //-------------------------------------------------------------
+ namespace endOnIsrCb
+ {
+ TIsrRequeArgs requeArgs[] = {
+ TIsrRequeArgs(),
+ TIsrRequeArgs(size,3*size,size,0, ETrue),
+ TIsrRequeArgs(size,4*size,size,0, ETrue),
+ TIsrRequeArgs(0,5*size,size,0, ETrue),
+ };
+ const TInt count = ARRAY_LENGTH(requeArgs);
+
+ // we expect a cb for each requeue + 1 for the original
+ // transfer
+ const TCallbackRecord callbackRecord = TCallbackRecord(TCallbackRecord::EIsr, count + 1).IsrRedoResult(KErrNone);
+ const TResultSet expected(KErrNone, requestResult, KErrNone, callbackRecord);
+
+ TTestCase testCase(new (ELeave) CIsrRequeTest(_L("4 Requeues - end on isr cb"), 1, tferArgs, requeArgs, count, expected, &KPreTransferIncrBytes, &KCompareSrcDst), ETrue, capAboveV1);
+ }
+
+ //---------------------------------------------------------------
+ ///This case requeues 4 transfers at the end of a thread callback
+ //---------------------------------------------------------------
+ namespace endOnThreadCb
+ {
+ TIsrRequeArgs requeArgs[] = {
+ TIsrRequeArgs(),
+ TIsrRequeArgs(size,3*size,size,0, ETrue),
+ TIsrRequeArgs(size,4*size,size,0, ETrue),
+ TIsrRequeArgs(0,5*size,size,0, EFalse),
+ };
+ const TInt count = ARRAY_LENGTH(requeArgs);
+
+ const TCallbackRecord callbackRecord = TCallbackRecord(TCallbackRecord::EThread, count + 1).IsrRedoResult(KErrNone);
+ const TResultSet expected(KErrNone, requestResult, KErrNone, callbackRecord);
+
+ TTestCase testCase(new (ELeave) CIsrRequeTest(_L("4 Requeues - end on thread cb"), 1, tferArgs, requeArgs, count, expected, &KPreTransferIncrBytes, &KCompareSrcDst), ETrue, capAboveV1);
+ }
+
+ //----------------------------------------------------------------------------------------------
+ // This case requeues a transfer from within an thread callback after changing the transfer size
+ //----------------------------------------------------------------------------------------------
+ namespace changeSize
+ {
+ TIsrRequeArgs requeArgs[] = {
+ TIsrRequeArgs(3*size,5*size,2*size,0, EFalse),
+ };
+ const TInt count = ARRAY_LENGTH(requeArgs);
+
+ const TCallbackRecord callbackRecord = TCallbackRecord(TCallbackRecord::EThread, count + 1).IsrRedoResult(KErrNone);
+ const TResultSet expected(KErrNone, requestResult, KErrNone, callbackRecord);
+
+ TTestCase testCase(new (ELeave) CIsrRequeTest(_L("1 Requeues - change transfer size"), 1, tferArgs, requeArgs, count, expected, &KPreTransferIncrBytes, &KCompareSrcDst), ETrue, capAboveV1);
+ }
+
+ //--------------------------------------------------------------------------------------------
+ // This case requeues a just completed request from within an ISR callback
+ //--------------------------------------------------------------------------------------------
+ namespace endOnRedo
+ {
+ // The transfer size has been made bigger than 4K so that we do not miss the second interrupt when tracing
+ // enabled is. This indicates the PSL's interrupt handler misses an interrupt if it occurs during the interrupt.
+ const TInt size = 0x10000;
+ TDmaTransferArgs tferArgs(0, 2*size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr);
+
+ TIsrRequeArgs requeArgs[] = {
+ TIsrRequeArgs(3*size,5*size,2*size,0, ETrue),
+ TIsrRequeArgs() //repeat the previous transfer
+ };
+ const TInt count = ARRAY_LENGTH(requeArgs);
+
+ const TCallbackRecord callbackRecord = TCallbackRecord(TCallbackRecord::EIsr, count + 1).IsrRedoResult(KErrNone);
+ const TResultSet expected(KErrNone, requestResult, KErrNone, callbackRecord);
+
+ TTestCase testCase(new (ELeave) CIsrRequeTest(_L("2 Requeues - Isr redo request repeated"), 1, tferArgs, requeArgs, count, expected, &KPreTransferIncrBytes, &KCompareSrcDst), EFalse, capAboveV1);
+ }
+
+ //--------------------------------------------------------------------------------------------
+ // This case requeues a request from within an ISR callback using invalid requeue parameters
+ //--------------------------------------------------------------------------------------------
+ namespace invalidAddresses
+ {
+ TIsrRequeArgs requeArgs[] = {
+ TIsrRequeArgs(size, size)
+ };
+ const TInt count = ARRAY_LENGTH(requeArgs);
+
+ const TCallbackRecord callbackRecord = TCallbackRecord(TCallbackRecord::EIsr, 1).IsrRedoResult(KErrArgument);
+ const TResultSet expected(KErrNone, requestResult, KErrUnknown, callbackRecord);
+
+ // pre and post test would fail because of bad requeue parameters
+ TTestCase testCase(new (ELeave) CIsrRequeTest(_L("Requeue with matching addresses"), 1, tferArgs, requeArgs, count, expected, NULL, NULL), ETrue, capAboveV1);
+ }
+ //--------------------------------------------------------------------------------------------
+ // This case requeues a request containing more than 1 fragment from within an ISR callback
+ //
+ //
+ // This test case is currently caught by a FAULT instead of a return code
+ // as expected. Currently, the facility to return an error code to the test
+ // framework is not yet supported.
+ //
+ // It has been implemented to expect an error code of KErrGeneral as requeues for request that
+ // contains more than one fragments are not allowed.
+ //--------------------------------------------------------------------------------------------
+ namespace multipleFragments
+ {
+ TIsrRequeArgs requeArgs[] = {
+ TIsrRequeArgs()
+ };
+ const TInt count = ARRAY_LENGTH(requeArgs);
+ const TRequestResults isrequestResult(KErrNone, 2); // request contains 2 fragments
+
+ const TCallbackRecord callbackRecord = TCallbackRecord(TCallbackRecord::EIsr, 1).IsrRedoResult(KErrGeneral);
+ TRequestResults results2Fragments = TRequestResults(isrequestResult).FragmentCount(2);
+ const TResultSet expected(KErrNone, results2Fragments, KErrNone, callbackRecord);
+
+ TTestCase testCase(new (ELeave) CIsrRequeTest(_L("Attempt to Requeue 2 fragment request"), 1, tferArgs, requeArgs, count, expected, &KPreTransferIncrBytes, &KCompareSrcDst, size/2), ETrue, capAboveV1);
+
+ }
+ }
+
+//----------------------------------------------------------------------------------------------
+//! TestCaseID PBASE-DMA-FUNC-2586
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc DMA Multiple transfer test
+//! TestActions
+//! 1.Setup DMA transfer to using muliple transfers.
+//! 2.Create multipart transfer test and run test.
+//!
+//!
+//! TestExpectedResults
+//! 1. DMA tranfer set up with no errors.
+//! 2. Multipart transfer tests completes with no issues.
+//!
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace Multipart
+ {
+ // need long transfer, to try and force adjacent
+ // requests to be concatinated
+ const TInt size = 2 * KMega;
+ const TDmaTransferArgs transferArgArray[] = {
+ TDmaTransferArgs(0, size, size, KDmaMemAddr),
+ TDmaTransferArgs(2 * size, 3 * size, size, KDmaMemAddr)
+ };
+
+ const TResultSet expected[] =
+ {
+ TResultSet(),
+ TResultSet()
+ };
+
+ CMultiTransferTest multipart =
+ CMultiTransferTest(_L("Sg request concatination"), 1, transferArgArray, expected, ARRAY_LENGTH(transferArgArray))
+ .SetPreTransferTest(&KPreTransferIncrBytes)
+ .SetPostTransferTest(&KCompareSrcDst);
+
+ TTestCase testCase(&multipart, EFalse, hwDesWanted_skip);
+ }
+
+//----------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2580
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc These tests attempt to queue ISR cb requests while the queue is not
+//! empty and queing normal requests when an ISR cb is pending
+//! TestActions
+//!
+//! 1. Setup DMA transfer to request a callback from ISR.
+//! 2. Create single transfer test and run test
+//! 3. Queue another request using Queue()before ISR Callback completion
+//! 4. Verify a DMA framework flags an error.
+//!
+//!
+//! TestExpectedResults
+//! DMA framework flags an error if ISR callback has not been executed
+//! for the last time without re-queueing the initial transfer request
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace IsrAndDfc
+ {
+ // This test case needs a long transfer so that 1st request is still queued when the second
+ // one is queued. The use of Pause is recommended in order to guarantee this. For this case,
+ // the size has been selected to ensure that the first isr callback request in IsrBeforeDfc
+ // will only have one fragment
+ const TInt size = 0x40000;
+ TDmaTransferArgs dfcTransfer(0, size, size, KDmaMemAddr);
+ TDmaTransferArgs isrTransfer(2*size, 3*size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr);
+
+ const TResultSet success = TResultSet();
+ TResultSet queueFailure = TResultSet().
+ RequestResult(TRequestResults().QueueResult(KErrGeneral)).
+ CallbackRecord(TCallbackRecord::Empty()).
+ PostTransferResult(1);
+
+ namespace DfcBeforeIsr
+ {
+ const TDmaTransferArgs transferArgArray[] = {
+ dfcTransfer,
+ isrTransfer
+ };
+
+ const TResultSet expected[] =
+ {
+ success,
+ queueFailure
+ };
+ CMultiTransferTest dfcBeforeIsr =
+ CMultiTransferTest(_L("DFC cb req before ISR cb req "), 1, transferArgArray, expected, ARRAY_LENGTH(transferArgArray))
+ .SetPreTransferTest(&KPreTransferIncrBytes)
+ .SetPostTransferTest(&KCompareSrcDst)
+ .PauseWhileQueuing();
+ TTestCase testCase(&dfcBeforeIsr, EFalse, pauseRequired_skip, capAboveV1);
+ }
+
+ namespace IsrBeforeDfc
+ {
+ const TDmaTransferArgs transferArgArray[] = {
+ isrTransfer,
+ dfcTransfer
+ };
+
+ TResultSet isrSuccess = TResultSet(success).CallbackRecord(isrCallback);
+ const TResultSet expected[] =
+ {
+ isrSuccess,
+ queueFailure
+ };
+ CMultiTransferTest dfcBeforeIsr =
+ CMultiTransferTest(_L("ISR cb req before DFC cb req "), 1, transferArgArray, expected, ARRAY_LENGTH(transferArgArray))
+ .SetPreTransferTest(&KPreTransferIncrBytes)
+ .SetPostTransferTest(&KCompareSrcDst)
+ .PauseWhileQueuing();
+ TTestCase testCase(&dfcBeforeIsr, EFalse, pauseRequired_skip, capAboveV1);
+ }
+
+ }
+
+//----------------------------------------------------------------------------------------------
+//! TestCaseID PBASE-DMA-FUNC-2587
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc DMA 2D transfer test
+//!
+//! TestActions
+//! 1. Set up DMA transfer using TDmaTransArgs parameters specified in order to
+//! rotate an image by 90 degrees clockwise.
+//! 2. Verify that destination buffer gets transformed according to the DMA
+//! transfer arguments after transfer.
+//!
+//! TestExpectedResults
+//! 1. DMA tranfer set up with no errors.
+//! 2. Destination buffer gets transformed accordingly.
+//!
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+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);
+ }
+
+//----------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2565
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc DMA Fragmentation count test
+//!
+//! TestActions
+//! 1. Set up the arguments for Fragment using the setting in the test scenario table below.
+//! 2. Create single transfer test and run test
+//! 3. Verify that FragmentCount API returns the expected value and framework responds correctly
+//! 4. Repeat steps 1 to 3 above until all the settings in the scenario table below have been used.
+//!
+//! TestExpectedResults
+//! On calling FragmentCount (), the number of fragments (descriptors / pseudo descriptors) that
+//! the transfer request has been split into is returned.
+//!
+//!
+//!
+//! TestPriority High
+//! TestStatus 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(new (ELeave) CMultiVersionTest(&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(new (ELeave) CMultiVersionTest(&test2), EFalse);
+
+ // Also specifying an element size to get the PIL to further adjust the
+ // fragment size(s): element size = 32, transfer length = 128KB, max
+ // transfer length = 6500 bytes, # of fragments expected = 21 (20 with 6496
+ // bytes each + 1 with 1152 bytes).
+ TDmaTransferArgs transferArgs3(0, size, size, KDmaMemAddr, KDmaSyncAuto, 0, KDmaAddrModePostIncrement, 32);
+ const TRequestResults requestResult3(KErrNone, 21);
+ const TResultSet expectedResults3(KErrNone, requestResult3, KErrNone, threadCallback);
+ CSingleTransferTest test3(_L("Fragmentation Count - 21 fragments"),
+ 1, transferArgs3, expectedResults3, 6500);
+ TTestCase testCase3(new (ELeave) CMultiVersionTest(&test3), EFalse);
+ }
+
+//----------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2584,KBASE-DMA-2585
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc DMA Benchmark tests
+//! To compare the speed of request fragmentation for a given transfer
+//! between the new and old frameworks on the NaviEngine platform.
+//! TestActions
+//! 1. Fragment a memory to memory dma transfer of 4Mb, where both source and destination are physically contiguous.
+//! 2. Fragment using the default element size, and also with a 4K limit.
+//! 3. Carry out for a channel using pseudo descriptors and for a scatter gather channel.
+//!
+//! TestExpectedResults
+//! The results obtained for both framework versions should be comparable.
+//!
+//! TestPriority High
+//! TestStatus 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, capAboveV1);
+ }
+ 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, capAboveV1);
+ }
+ }
+
+ 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, capAboveV1);
+ }
+ 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, capAboveV1);
+ }
+ }
+ }
+ }
+
+//----------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2560
+//! TestCaseID KBASE-DMA-2561
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc Test new & old style fragment using CSingleTransferTest
+//! Test Scenario 1 - DstAddr > SrcAddr & TransferSize=32K & Location is
+//! address of a memory buffer
+//! TestActions
+//! 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
+//!
+//! TestExpectedResults
+//! 1. TransfeArgs set up in DMA framework
+//! 2. Expected results set up in DMA framework
+//! 3. Fragment request completes and KErrNone returned
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace Fragment_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);
+
+ CMultiVersionTest multiVersion(new (ELeave) CSingleTransferTest(_L("Fragment - Scenario 1"), 1, transferArgs, expectedResults,KKilo));
+
+ TTestCase testCase(&multiVersion, EFalse);
+ TTestCase testCaseConcurrent(&multiVersion, ETrue);
+ }
+
+//----------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2560
+//! TestCaseID KBASE-DMA-2561
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc Test new & old style fragment 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
+//!
+//!
+//! TestExpectedResults
+//!
+//! 1. TransfeArgs set up in DMA framework
+//! 2. Expected results set up in DMA framework
+//! 3. Fragment request fails and KErrArgument returned
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace Fragment_2
+ {
+ const TInt srcAddr = 32 * KKilo;
+ const TInt desAddr = 64 * KKilo;
+ const TInt transferSize = 0;
+
+ TDmaTransferArgs transferArgs( srcAddr, desAddr, transferSize,KDmaMemAddr);
+ const TRequestResults requestResult(KErrNone, 0, KErrArgument, KErrUnknown);
+ const TResultSet expectedResults(KErrNone, requestResult, KErrNone, TCallbackRecord::Empty());
+
+
+ CMultiVersionTest multiVersion(new (ELeave) CSingleTransferTest(_L("Fragment - Scenario 3"), 1, transferArgs, expectedResults));
+
+ TTestCase testCase(&multiVersion, EFalse);
+ TTestCase testCaseConcurrent(&multiVersion, ETrue);
+ }
+
+//----------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2560
+//! TestCaseID KBASE-DMA-2561
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc Test new & old style fragment 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
+//!
+//! TestExpectedResults
+//!
+//! 1. TransfeArgs set up in DMA framework
+//! 2. Expected results set up in DMA framework
+//! 3. Fragment request completes and KErrNone returned
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace Fragment_3
+ {
+ 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);
+
+ CMultiVersionTest multiVersion(new (ELeave) CSingleTransferTest(_L("Fragment - Scenario 4"), 1, transferArgs, expectedResults));
+
+ TTestCase testCase(&multiVersion, EFalse);
+ TTestCase testCaseConcurrent(&multiVersion, ETrue);
+ }
+
+//----------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2560
+//! TestCaseID KBASE-DMA-2561
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc Test new & old style fragment 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
+//!
+//! TestExpectedResults
+//!
+//! 1. TransfeArgs set up in DMA framework
+//! 2. Expected results set up in DMA framework
+//! 3. Fragment request completes and KErrNone returned
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace Fragment_4
+ {
+ 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);
+
+ CMultiVersionTest multiVersion(new (ELeave) CSingleTransferTest(_L("Fragment - Scenario 5"), 1, transferArgs, expectedResults));
+
+ TTestCase testCase(&multiVersion, EFalse);
+ TTestCase testCaseConcurrent(&multiVersion, ETrue);
+ }
+
+//----------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2560
+//! TestCaseID KBASE-DMA-2561
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc Test new & old style fragment 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
+//!
+//! TestExpectedResults
+//!
+//! 1. TransfeArgs set up in DMA framework
+//! 2. Expected results set up in DMA framework
+//! 3. Fragment request completes and KErrNone returned
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace Fragment_5
+ {
+ 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);
+
+ CMultiVersionTest multiVersion(new (ELeave) CSingleTransferTest(_L("Fragment - Scenario 6"), 1, transferArgs, expectedResults));
+
+ TTestCase testCase(&multiVersion, EFalse);
+ TTestCase testCaseConcurrent(&multiVersion, ETrue);
+ }
+
+
+//----------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2562
+//! TestCaseID KBASE-DMA-2563
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc Test new and old style DDmaRequest 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
+//!
+//! TestExpectedResults
+//!
+//! 1. TransfeArgs set up in DMA framework
+//! 2. Expected results set up in DMA framework
+//! 3. DDmaRequest constructor behaves as expected and KErrArgument returned
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//------------------------------------------------------------------------------------------------
+namespace DDmaRequest_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);
+
+ CMultiVersionTest multiVersion(new (ELeave) CSingleTransferTest(_L("DDmaRequest - Scenario 1"), 1, transferArgs, expectedResults,0));
+
+ TTestCase testCase(&multiVersion, EFalse);
+ TTestCase testCaseConcurrent(&multiVersion, ETrue);
+ }
+
+//!-------------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2562
+//! TestCaseID KBASE-DMA-2563
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc Test new and old style DDmaRequest using CSingleTransferTest
+//! Test Scenario 2 - aMaxTransferSize= (64K - 1) // 65535
+//!
+//! 1. Set up the arguments for DDmaRequest using aMaxTransferSize set to (64K - 1).
+//! 2. Setup expected result.
+//! 3. Create single transfer test and run test
+//!
+//! TestExpectedResults
+//!
+//! 1. TransfeArgs set up in DMA framework
+//! 2. Expected results set up in DMA framework
+//! 3. DDmaRequest constructor behaves as expected and KErrArgument returned
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//---------------------------------------------------------------------------------------------------
+namespace DDmaRequest_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);
+
+ CMultiVersionTest multiVersion(new (ELeave) CSingleTransferTest(_L("DDmaRequest - Scenario 2"), 1, transferArgs, expectedResults, trans64K_1));
+
+ TTestCase testCase(&multiVersion, EFalse);
+ TTestCase testCaseConcurrent(&multiVersion, ETrue);
+ }
+
+//----------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2585
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc 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
+//!
+//! TestActions
+//! 1. Open a DMA channel for a transfer.
+//! 2. Create single transfer test using small frags and run test
+//!
+//! TestExpectedResults
+//! 1. DMA channel opens and KErrNone returned.
+//! 2. DMA transfer completes with no errors.
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace SmallFrags
+ {
+ const TInt size = 32;
+ TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr);
+
+ const TResultSet expectedResults(threadCallback);
+
+ TTestCase testCase(
+ new (ELeave) CMultiVersionTest(new (ELeave) CSingleTransferTest(_L("8 * 4byte frags"), 10, transferArgs, expectedResults, 4)),
+ EFalse);
+ }
+
+//----------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2568
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc This test checks the correct behaviour of Close API in the new DMA framework
+//!
+//! TestActions
+//! 1. Open a DMA channel
+//! 2. Open DMA Channel again
+//! 3 Close the DMA channel.
+//! 4 Open DMA channel to verify that the DMA channel closed.
+//!
+//! TestExpectedResults
+//! 1. DMA channel opens and KErrNone returned.
+//! 2. DMA Framework returns KErrInUse as channel is already open.
+//! 3. DMA channel closes and KErrNone returned.
+//! 4. DMA channel opens and KErrNone returned.
+//!
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace CloseApiTest
+ {
+ COpenCloseTest testCloseApi = COpenCloseTest(_L("Close API Test"), 1).RunOpenApiTest(EFalse);
+ TTestCase testCaseCloseApi(&testCloseApi, EFalse, capAboveV1);
+ }
+
+//----------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2564
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc This test checks the correct behaviour of Open API in the new DMA framework
+//!
+//! TestActions
+//! 1. Open a DMA channel
+//! 2. Verify that channel is really open by closing DMA channel
+//!
+//! TestExpectedResults
+//! 1. DMA channel opens and KErrNone returned
+//! 2. DMA channel closes again returns KErrNone.
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace OpenApiTest
+ {
+ COpenCloseTest testOpenApi = COpenCloseTest(_L("Open API Test"), 1).RunOpenApiTest(ETrue);
+ TTestCase testCaseOpenApi(&testOpenApi, EFalse, capAboveV1);
+ }
+
+//----------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2567
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc This test verifies the correct behavior of TBool IsQueueEmpty() in the new DMA
+//! framework and check its return value
+//!
+//! TestActions
+//! 1. Open a single DMA channel for a transfer.
+//! 2. Setup a DMA request and Fragment the request.
+//! 3. Call IsQueueEmpty().
+//! 4. Queue the DMA request.
+//! 5. Call IsQueueEmpty().
+//! TestExpectedResults
+//! 1. DMA channel opens and KErrNone returned.
+//! 2. DMA request created and fragmented and KErrNone returned.
+//! 3. IsQueueEmpty() returns ETrue.
+//! 4. Request queued and KErrNone returned
+//! 5. IsQueueEmpty() returns EFalse.
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace IsQueueEmptyTest
+ {
+ const TInt size = 2 * KMega;
+ const TDmaTransferArgs transferArgArray[] = {
+ TDmaTransferArgs(0, size, size, KDmaMemAddr),
+ TDmaTransferArgs(2 * size, 3 * size, size, KDmaMemAddr)
+ };
+
+ const TResultSet expected[] =
+ {
+ TResultSet(),
+ TResultSet()
+ };
+ const TResultSet expectedResults(isrCallback);
+
+ CIsQueueEmptyTest isQueueEmpty =
+ CIsQueueEmptyTest(_L("IsQueueEmptyTest using muliple frags"), 1, transferArgArray, expected, ARRAY_LENGTH(transferArgArray))
+ .SetPreTransferTest(&KPreTransferIncrBytes)
+ .SetPostTransferTest(&KCompareSrcDst);
+
+ TTestCase testCase(&isQueueEmpty,EFalse,capAboveV1,pauseRequired_skip);
+ }
+
+//--------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2573
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc This test verifies the correct behavior of the DMA Channel Linking API
+//! in the new DMA framework
+//!
+//! TestActions
+//! 1. Open a DMA channel for a transfer.
+//! 2. Link and Unlink DMA channel.
+//! 3. Close DMA channel.
+//!
+//!
+//! TestExpectedResults 1. DMA channel opens and KErrNone returned.
+//! 2. KErrNotSupported returned when DMA Linking and Unlinking API are called.
+//! 3. DMA channel closes and KErrNone returned.
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace ChannelLinkingTest
+ {
+ const TInt srcAddr = 0;
+ const TInt desAddr = 2 * KMega;
+ const TInt transferSize = 1 * KMega;
+
+ TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize, KDmaMemAddr);
+
+ TResultSet noTransferExpected = TResultSet().
+ RequestResult(TRequestResults().CreationResult(KErrUnknown).FragmentationResult(KErrUnknown).QueueResult(KErrUnknown)).
+ CallbackRecord(TCallbackRecord::Empty()).
+ PostTransferResult(KErrUnknown);
+
+ CLinkChannelTest testChannelLinking = CLinkChannelTest(_L("DMA Channel Linking and Unlinking Negative Test"), 1, transferArgs, noTransferExpected);
+ TTestCase testCaseChannelLinking(&testChannelLinking , EFalse, capAboveV1,LinkingNotWanted);
+ }
+
+//--------------------------------------------------------------------------------------------
+//! TestCaseID KBASE-DMA-2574
+//! TestType CIT
+//! PREQ REQ
+//! TestCaseDesc This test verifies that the DMA Element Counting APIs can be called. The calls
+//! to these functions are meant to be used to meet a code coverage requirement.These APIs
+//! are not yet supported so the functionality of the APIs are not currently tested.
+//!
+//! TestActions
+//! 1. Open a DMA channel for a transfer.
+//! 2. Make calls to Element Counting APIs
+//! 3. Close DMA channel.
+//!
+//!
+//! TestExpectedResults 1. DMA channel opens and KErrNone returned.
+//! 2. Element Counting APIs are called without crashing the framework
+//! 3. DMA channel closes and KErrNone returned.
+//!
+//! TestPriority High
+//! TestStatus Implemented
+//----------------------------------------------------------------------------------------------
+namespace ElementCountingTest
+ {
+ const TInt srcAddr = 0;
+ const TInt desAddr = 2 * KMega;
+ const TInt transferSize = 1 * KMega;
+
+ TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize, KDmaMemAddr);
+
+ const TResultSet expectedResults(threadCallback);
+ CElementCountingTest testElementCounting(_L("DMA Element Counting Test"), 1, transferArgs, expectedResults);
+ TTestCase testCaseElementCounting(&testElementCounting, EFalse, capAboveV1);
+ }
+
+static TTestCase* StaticSimpleTestArray[] = {
+ &Simple_1::testCase,
+ &Simple_1::testCaseConcurrent,
+};
+
+static TTestCase* StaticCallbackTestArray[] = {
+ &Callback::testCase,
+ &Callback::testCaseOldRequest,
+};
+
+static TTestCase* StaticIsrRequeTestArray[] = {
+ &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
+#ifdef _REMOVEDTEST
+ // This test case is currently caught by a FAULT instead of a return code
+ // as expected. Currently, the facility to return an error code to the test
+ // framework is not yet supported.
+ &ISR_Reque::multipleFragments::testCase,
+#endif
+};
+
+static TTestCase* StaticMultipartTestArray[] = {
+ &Multipart::testCase,
+};
+
+static TTestCase* StaticIsrAndDfcTestArray[] = {
+ &IsrAndDfc::DfcBeforeIsr::testCase,
+ &IsrAndDfc::IsrBeforeDfc::testCase,
+};
+
+static TTestCase* Static2DTestArray[] = {
+ &_2D_Test::testCase2d
+};
+
+static TTestCase* StaticFragmentTestArray[] = {
+ &FragmentationCount::testCase,
+ &FragmentationCount::testCase2,
+ &SmallFrags::testCase,
+ &Fragment_1::testCase,
+ &Fragment_1::testCaseConcurrent,
+ &Fragment_2::testCase,
+ &Fragment_2::testCaseConcurrent,
+ &Fragment_3::testCase,
+ &Fragment_3::testCaseConcurrent,
+ &Fragment_4::testCase,
+ &Fragment_4::testCaseConcurrent,
+ &Fragment_5::testCase,
+ &Fragment_5::testCaseConcurrent,
+};
+
+static TTestCase* StaticBenchmarkTestArray[] = {
+ // 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,
+};
+
+static TTestCase* StaticRequestTestArray[] = {
+ &DDmaRequest_1::testCase,
+ &DDmaRequest_1::testCaseConcurrent,
+ &DDmaRequest_2::testCase,
+ &DDmaRequest_2::testCaseConcurrent,
+};
+
+static TTestCase* StaticChannelTestArray[] = {
+ &CloseApiTest::testCaseCloseApi,
+ &OpenApiTest::testCaseOpenApi,
+};
+
+static TTestCase* StaticSuspendTestArray[] = {
+ &PauseResumeApiTest::testCasePauseResume,
+ &PauseResumeApiNegTest::testCasePauseResumeNeg,
+};
+
+static TTestCase* StaticQueueTestArray[] = {
+ &CancelAllTest::testCase,
+ &IsQueueEmptyTest::testCase,
+};
+
+//Append new test cases here
+static TTestCase* StaticTestArray[] = {
+ &Simple_1::testCase,
+ &Simple_1::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
+#ifdef _REMOVEDTEST
+ // This test case is currently caught by a FAULT instead of a return code
+ // as expected. Currently, the facility to return an error code to the test
+ // framework is not yet supported.
+ &ISR_Reque::multipleFragments::testCase,
+#endif
+ &Multipart::testCase,
+ &IsrAndDfc::DfcBeforeIsr::testCase,
+ &IsrAndDfc::IsrBeforeDfc::testCase,
+ &_2D_Test::testCase2d,
+ &FragmentationCount::testCase,
+ &FragmentationCount::testCase2,
+ &FragmentationCount::testCase3,
+ &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
+ &Fragment_1::testCase,
+ &Fragment_1::testCaseConcurrent,
+ &Fragment_2::testCase,
+ &Fragment_2::testCaseConcurrent,
+ &Fragment_3::testCase,
+ &Fragment_3::testCaseConcurrent,
+ &Fragment_4::testCase,
+ &Fragment_4::testCaseConcurrent,
+ &Fragment_5::testCase,
+ &Fragment_5::testCaseConcurrent,
+ &DDmaRequest_1::testCase,
+ &DDmaRequest_1::testCaseConcurrent,
+ &DDmaRequest_2::testCase,
+ &DDmaRequest_2::testCaseConcurrent,
+ &CloseApiTest::testCaseCloseApi,
+ &OpenApiTest::testCaseOpenApi,
+ &PauseResumeApiTest::testCasePauseResume,
+ &PauseResumeApiNegTest::testCasePauseResumeNeg,
+ &CancelAllTest::testCase,
+ &IsQueueEmptyTest::testCase,
+ &ChannelLinkingTest::testCaseChannelLinking,
+ &ElementCountingTest::testCaseElementCounting,
+};
+
+RPointerArray<TTestCase> TestArray(StaticTestArray, ARRAY_LENGTH(StaticTestArray));
+RPointerArray<TTestCase> TestArrayIsrAndDfc(StaticIsrAndDfcTestArray, ARRAY_LENGTH(StaticIsrAndDfcTestArray));
+RPointerArray<TTestCase> TestArraySimple(StaticSimpleTestArray, ARRAY_LENGTH(StaticSimpleTestArray));
+RPointerArray<TTestCase> TestArrayQueue(StaticQueueTestArray, ARRAY_LENGTH(StaticQueueTestArray));
+RPointerArray<TTestCase> TestArrayChannel(StaticChannelTestArray, ARRAY_LENGTH(StaticChannelTestArray));
+RPointerArray<TTestCase> TestArraySuspend(StaticSuspendTestArray, ARRAY_LENGTH(StaticSuspendTestArray));
+RPointerArray<TTestCase> TestArrayFragment(StaticFragmentTestArray, ARRAY_LENGTH(StaticFragmentTestArray));
+RPointerArray<TTestCase> TestArrayBenchmark(StaticBenchmarkTestArray, ARRAY_LENGTH(StaticBenchmarkTestArray));
+RPointerArray<TTestCase> TestArray2DTest(Static2DTestArray, ARRAY_LENGTH(Static2DTestArray));
+RPointerArray<TTestCase> TestArrayMultiPart(StaticMultipartTestArray, ARRAY_LENGTH(StaticMultipartTestArray));
+RPointerArray<TTestCase> TestArrayIsrReque(StaticIsrRequeTestArray, ARRAY_LENGTH(StaticIsrRequeTestArray));
+RPointerArray<TTestCase> TestArrayCallback(StaticCallbackTestArray, ARRAY_LENGTH(StaticCallbackTestArray));
+RPointerArray<TTestCase> TestArrayRequest(StaticRequestTestArray, ARRAY_LENGTH(StaticRequestTestArray));