diff -r c1f20ce4abcf -r 3e88ff8f41d5 kerneltest/e32test/dmav2/test_cases.cpp --- a/kerneltest/e32test/dmav2/test_cases.cpp Tue Aug 31 16:34:26 2010 +0300 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1393 +0,0 @@ -/* -* 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 TestArray(StaticTestArray, ARRAY_LENGTH(StaticTestArray)); -RPointerArray TestArrayIsrAndDfc(StaticIsrAndDfcTestArray, ARRAY_LENGTH(StaticIsrAndDfcTestArray)); -RPointerArray TestArraySimple(StaticSimpleTestArray, ARRAY_LENGTH(StaticSimpleTestArray)); -RPointerArray TestArrayQueue(StaticQueueTestArray, ARRAY_LENGTH(StaticQueueTestArray)); -RPointerArray TestArrayChannel(StaticChannelTestArray, ARRAY_LENGTH(StaticChannelTestArray)); -RPointerArray TestArraySuspend(StaticSuspendTestArray, ARRAY_LENGTH(StaticSuspendTestArray)); -RPointerArray TestArrayFragment(StaticFragmentTestArray, ARRAY_LENGTH(StaticFragmentTestArray)); -RPointerArray TestArrayBenchmark(StaticBenchmarkTestArray, ARRAY_LENGTH(StaticBenchmarkTestArray)); -RPointerArray TestArray2DTest(Static2DTestArray, ARRAY_LENGTH(Static2DTestArray)); -RPointerArray TestArrayMultiPart(StaticMultipartTestArray, ARRAY_LENGTH(StaticMultipartTestArray)); -RPointerArray TestArrayIsrReque(StaticIsrRequeTestArray, ARRAY_LENGTH(StaticIsrRequeTestArray)); -RPointerArray TestArrayCallback(StaticCallbackTestArray, ARRAY_LENGTH(StaticCallbackTestArray)); -RPointerArray TestArrayRequest(StaticRequestTestArray, ARRAY_LENGTH(StaticRequestTestArray));