diff -r a990138eda40 -r c30940f6d922 kerneltest/e32test/dmav2/test_cases.cpp --- a/kerneltest/e32test/dmav2/test_cases.cpp Thu Apr 29 11:08:53 2010 +0100 +++ b/kerneltest/e32test/dmav2/test_cases.cpp Tue May 04 09:44:26 2010 +0100 @@ -24,24 +24,121 @@ const TCallbackRecord isrCallback(TCallbackRecord::EIsr,1); const TInt size = 128 * KKilo; -//-------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2560 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc Simple DMA transfer test using CSingleTransferTest and New DMA APIs +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 //! -//! @SYMTestActions -//! 1. -//! 2. +//! 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 //! //! -//! @SYMTestExpectedResults -//! 1. -//! 2. +//! 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-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. //! //! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented +//! TestPriority High +//! TestStatus Implemented //---------------------------------------------------------------------------------------------- namespace Simple_1 { @@ -51,60 +148,29 @@ CSingleTransferTest simpleTest(_L("Simple Test - New DMA APIs"), 1, transferArgs, expectedResults); - TTestCase testCase(&simpleTest, EFalse, capAboveV1); - TTestCase testCaseConcurrent(&simpleTest, ETrue, capAboveV1); + TTestCase testCase(new (ELeave) CMultiVersionTest(&simpleTest), EFalse); + TTestCase testCaseConcurrent(new (ELeave) CMultiVersionTest(&simpleTest), ETrue); } //---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2561 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc Simple DMA transfer test using CSingleTransferTest and OLD DMA APIs -//! -//! @SYMTestActions -//! 1. -//! 2. -//! -//! -//! @SYMTestExpectedResults -//! 1. -//! 2. -//! +//! TestCaseID KBASE-DMA-2573 +//! TestType CIT +//! PREQ REQ +//! TestCaseDesc DMA ISR Callback test (Isr Callback - use old request Ctor) //! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented -//---------------------------------------------------------------------------------------------- -namespace Simple_2 - { - TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr); - - const TResultSet expectedResults(threadCallback); - - CSingleTransferTest simpleTest = CSingleTransferTest(_L("Simple Test - Old DMA APIs"), 1, transferArgs, expectedResults, 0). - UseNewDmaApi(EFalse); - - TTestCase testCase(&simpleTest, EFalse); - TTestCase testCaseConcurrent(&simpleTest, ETrue); - } - -//---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2573 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc DMA ISR Callback test (Isr Callback - use old request Ctor) +//! 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 //! -//! @SYMTestActions -//! 1. -//! 2. -//! +//! TestExpectedResults +//! 1. DMA channel opens and KErrNone returned. +//! 2. DMA transfer created with no errors. +//! 3. DDmaRequest request fails. +//! //! -//! @SYMTestExpectedResults -//! 1. -//! 2. -//! -//! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented +//! TestPriority High +//! TestStatus Implemented //---------------------------------------------------------------------------------------------- namespace Callback { @@ -131,23 +197,25 @@ } //---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2574,KBASE-DMA-2575 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc DMA ISR Reque test +//! TestCaseID KBASE-DMA-2574,KBASE-DMA-2575 +//! TestType CIT +//! PREQ REQ +//! TestCaseDesc DMA ISR Reque test //! -//! @SYMTestActions -//! 1. -//! 2. +//! 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. //! -//! -//! @SYMTestExpectedResults -//! 1. -//! 2. +//! 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 //! //! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented +//! TestPriority High +//! TestStatus Implemented //---------------------------------------------------------------------------------------------- namespace ISR_Reque { @@ -156,6 +224,9 @@ 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[] = { @@ -174,6 +245,9 @@ 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[] = { @@ -189,7 +263,10 @@ 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[] = { @@ -203,10 +280,13 @@ 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 { - // TODO have made this bigger than 4k so that we don't miss the second interrupt when tracing enabled - // this indicates the PSL's interrupt handler misses an interrupt if it occurs during the interrupt. + // 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); @@ -222,6 +302,9 @@ 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[] = { @@ -235,41 +318,51 @@ // 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::EThread, count + 1).IsrRedoResult(KErrNone); - - TRequestResults results2Fragments = TRequestResults(requestResult).FragmentCount(2); + 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); } - } + } //---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID PBASE-DMA-FUNC-xxx -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc DMA Multiple transfer test -//! @SYMTestActions -//! 1. -//! 2. +//! 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. //! //! -//! @SYMTestExpectedResults -//! 1. -//! 2. +//! TestExpectedResults +//! 1. DMA tranfer set up with no errors. +//! 2. Multipart transfer tests completes with no issues. //! //! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented +//! TestPriority High +//! TestStatus Implemented //---------------------------------------------------------------------------------------------- namespace Multipart { @@ -278,7 +371,7 @@ const TInt size = 2 * KMega; const TDmaTransferArgs transferArgArray[] = { TDmaTransferArgs(0, size, size, KDmaMemAddr), - TDmaTransferArgs(size, 2 * size, size, KDmaMemAddr) + TDmaTransferArgs(2 * size, 3 * size, size, KDmaMemAddr) }; const TResultSet expected[] = @@ -286,7 +379,6 @@ TResultSet(), TResultSet() }; - const TResultSet expectedResults(isrCallback); CMultiTransferTest multipart = CMultiTransferTest(_L("Sg request concatination"), 1, transferArgArray, expected, ARRAY_LENGTH(transferArgArray)) @@ -297,32 +389,32 @@ } //---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2580 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc These tests attempt to queue ISR cb requests while the queue is not -//! empty and queing normal requests when an ISR cb is pending -//! @SYMTestActions -//! 1. -//! 2. +//! 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. //! //! -//! @SYMTestExpectedResults -//! 1. -//! 2. -//! +//! TestExpectedResults +//! DMA framework flags an error if ISR callback has not been executed +//! for the last time without re-queueing the initial transfer request //! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented +//! TestPriority High +//! TestStatus Implemented //---------------------------------------------------------------------------------------------- namespace IsrAndDfc { - // need long transfer, so that 1st request is still queued - // when the second one is queued - // TODO pause is the better way to ensure this - //const TInt size = 2 * KMega; - //TODO have changed size to ensure that the first isr callback request in IsrBeforeDfc - //will only have one fragment + // 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); @@ -348,8 +440,9 @@ CMultiTransferTest dfcBeforeIsr = CMultiTransferTest(_L("DFC cb req before ISR cb req "), 1, transferArgArray, expected, ARRAY_LENGTH(transferArgArray)) .SetPreTransferTest(&KPreTransferIncrBytes) - .SetPostTransferTest(&KCompareSrcDst); - TTestCase testCase(&dfcBeforeIsr, EFalse, hwDesWanted_skip); + .SetPostTransferTest(&KCompareSrcDst) + .PauseWhileQueuing(); + TTestCase testCase(&dfcBeforeIsr, EFalse, pauseRequired_skip, capAboveV1); } namespace IsrBeforeDfc @@ -368,30 +461,32 @@ CMultiTransferTest dfcBeforeIsr = CMultiTransferTest(_L("ISR cb req before DFC cb req "), 1, transferArgArray, expected, ARRAY_LENGTH(transferArgArray)) .SetPreTransferTest(&KPreTransferIncrBytes) - .SetPostTransferTest(&KCompareSrcDst); - TTestCase testCase(&dfcBeforeIsr, EFalse, hwDesWanted_skip); + .SetPostTransferTest(&KCompareSrcDst) + .PauseWhileQueuing(); + TTestCase testCase(&dfcBeforeIsr, EFalse, pauseRequired_skip, capAboveV1); } } //---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID PBASE-DMA-FUNC-xxx -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc DMA 2D transfer test +//! TestCaseID PBASE-DMA-FUNC-2587 +//! TestType CIT +//! PREQ REQ +//! TestCaseDesc DMA 2D transfer test //! -//! @SYMTestActions -//! 1. -//! 2. +//! 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. //! -//! -//! @SYMTestExpectedResults -//! 1. -//! 2. +//! TestExpectedResults +//! 1. DMA tranfer set up with no errors. +//! 2. Destination buffer gets transformed accordingly. //! //! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented +//! TestPriority High +//! TestStatus Implemented //---------------------------------------------------------------------------------------------- namespace _2D_Test { @@ -429,23 +524,25 @@ } //---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2565 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc DMA Fragmentation count test +//! TestCaseID KBASE-DMA-2565 +//! TestType CIT +//! PREQ REQ +//! TestCaseDesc DMA Fragmentation count test //! -//! @SYMTestActions -//! 1. -//! 2. +//! 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. //! -//! -//! @SYMTestExpectedResults -//! 1. -//! 2. +//! TestExpectedResults +//! On calling FragmentCount (), the number of fragments (descriptors / pseudo descriptors) that +//! the transfer request has been split into is returned. +//! //! //! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented +//! TestPriority High +//! TestStatus Implemented //---------------------------------------------------------------------------------------------- namespace FragmentationCount { @@ -454,32 +551,42 @@ const TRequestResults requestResult(KErrNone, 128); const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); CSingleTransferTest test1(_L("Fragmentation Count - 128 fragments"), 1, transferArgs, expectedResults, KKilo); - TTestCase testCase(&test1, EFalse); + 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(&test2, EFalse); + 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); } //---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2584,KBASE-DMA-2585 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc DMA Benchmark tests -//! -//! @SYMTestActions -//! 1. -//! 2. +//! 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. //! -//! @SYMTestExpectedResults -//! 1. -//! 2. -//! -//! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented +//! TestPriority High +//! TestStatus Implemented //----------------------------------------------------------------------------------------------- namespace Benchmark { @@ -489,8 +596,8 @@ 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); + 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 @@ -509,16 +616,16 @@ 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); + 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 + namespace _4MB { const TInt size = 4 * KMega; TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr); - CDmaBmTransfer bmTest(_L("4 Mb"), bmIters, transferArgs, 0); + CDmaBmTransfer bmTest(_L("4 MB"), bmIters, transferArgs, 0); TTestCase testCase(&bmTest, EFalse); } } @@ -544,7 +651,7 @@ CDmaBmTransfer bmTest = CDmaBmTransfer(_L("4 bytes DFC cb"), iterations, transferArgs, 0). UseNewDmaApi(ETrue). ExpectedResults(expected); - TTestCase testCase(&bmTest, EFalse); + TTestCase testCase(&bmTest, EFalse, capAboveV1); } namespace _4K { @@ -553,7 +660,7 @@ CDmaBmTransfer bmTest = CDmaBmTransfer(_L("4K DFC cb"), iterations, transferArgs, 0). UseNewDmaApi(ETrue). ExpectedResults(expected); - TTestCase testCase(&bmTest, EFalse); + TTestCase testCase(&bmTest, EFalse, capAboveV1); } } @@ -569,7 +676,7 @@ CDmaBmTransfer bmTest = CDmaBmTransfer(_L("4 bytes Isr cb"), iterations, transferArgs, 0). UseNewDmaApi(ETrue). ExpectedResults(expected); - TTestCase testCase(&bmTest, EFalse); + TTestCase testCase(&bmTest, EFalse, capAboveV1); } namespace _4K { @@ -578,20 +685,21 @@ CDmaBmTransfer bmTest = CDmaBmTransfer(_L("4K Isr cb"), iterations, transferArgs, 0). UseNewDmaApi(ETrue). ExpectedResults(expected); - TTestCase testCase(&bmTest, EFalse); + TTestCase testCase(&bmTest, EFalse, capAboveV1); } } } } //---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2560 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc TestNewStyleFragment using CSingleTransferTest +//! 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 -//! @SYMTestActions +//! TestActions //! 1. Set up the arguments for aTransfeArgs using the settings below. //! //! SrcAddr = 4 * KKilo; @@ -602,15 +710,15 @@ //! 2. Setup expected result. //! 3. Create single transfer test and run test //! -//! @SYMTestExpectedResults +//! TestExpectedResults //! 1. TransfeArgs set up in DMA framework //! 2. Expected results set up in DMA framework //! 3. Fragment request completes and KErrNone returned //! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented +//! TestPriority High +//! TestStatus Implemented //---------------------------------------------------------------------------------------------- -namespace TestNewStyleFragment_1 +namespace Fragment_1 { const TInt srcAddr = 4 * KKilo; const TInt desAddr = 64 * KKilo; @@ -622,59 +730,18 @@ const TRequestResults requestResult(KErrNone, 32); const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); - CSingleTransferTest testscenario_1(_L("TestNewStyleFragment - Test Scenario 1"), 1, transferArgs, expectedResults,KKilo); + CMultiVersionTest multiVersion(new (ELeave) CSingleTransferTest(_L("Fragment - Scenario 1"), 1, transferArgs, expectedResults,KKilo)); - TTestCase testCase(&testscenario_1, EFalse, capAboveV1); - TTestCase testCaseConcurrent(&testscenario_1, ETrue, capAboveV1); + TTestCase testCase(&multiVersion, EFalse); + TTestCase testCaseConcurrent(&multiVersion, ETrue); } //---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2560 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc TestNewStyleFragment using CSingleTransferTest -//! Test Scenario 2 - SrcAddr == DstAddr -//! -//! 1. Set up the arguments for aTransfeArgs using the settings below. -//! -//! SrcAddr = 4 * KKilo; -//! desAddr = 4 * KKilo; -//! transferSize = 32 * KKilo; -//! iFlags = KDmaMemAddr; -//! -//! 2. Setup expected result. -//! 3. Create single transfer test and run test -//! -//! @SYMTestExpectedResults -//! -//! 1. TransfeArgs set up in DMA framework -//! 2. Expected results set up in DMA framework -//! 3. Fragment passes and KErrNone returned -//! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented -//---------------------------------------------------------------------------------------------- -namespace TestNewStyleFragment_2 - { - const TInt srcAddr = 4 * KKilo; - const TInt desAddr = 4 * KKilo; - const TInt transferSize = 32 * KKilo; - - TDmaTransferArgs transferArgs(srcAddr,desAddr, transferSize, KDmaMemAddr); - const TRequestResults requestResult(KErrNone, 32); - const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); - - CSingleTransferTest testscenario_2(_L("TestNewStyleFragment - Test Scenario 2"), 1, transferArgs, expectedResults,KKilo); - - TTestCase testCase(&testscenario_2, EFalse, capAboveV1); - TTestCase testCaseConcurrent(&testscenario_2, ETrue, capAboveV1); - } - -//---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2560 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc TestNewStyleFragment using CSingleTransferTest +//! 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. @@ -688,36 +755,38 @@ //! 3. Create single transfer test and run test //! //! -//! @SYMTestExpectedResults +//! TestExpectedResults //! //! 1. TransfeArgs set up in DMA framework //! 2. Expected results set up in DMA framework //! 3. Fragment request fails and KErrArgument returned //! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented +//! TestPriority High +//! TestStatus Implemented //---------------------------------------------------------------------------------------------- -namespace TestNewStyleFragment_3 +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(KErrArgument, 0); - const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); + const TRequestResults requestResult(KErrNone, 0, KErrArgument, KErrUnknown); + const TResultSet expectedResults(KErrNone, requestResult, KErrNone, TCallbackRecord::Empty()); + - CSingleTransferTest testscenario_3(_L("TestNewStyleFragment - Test Scenario 3"), 1, transferArgs, expectedResults); + CMultiVersionTest multiVersion(new (ELeave) CSingleTransferTest(_L("Fragment - Scenario 3"), 1, transferArgs, expectedResults)); - TTestCase testCase(&testscenario_3, EFalse, capAboveV1); - TTestCase testCaseConcurrent(&testscenario_3, ETrue, capAboveV1); + TTestCase testCase(&multiVersion, EFalse); + TTestCase testCaseConcurrent(&multiVersion, ETrue); } //---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2560 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc TestNewStyleFragment using CSingleTransferTest +//! 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. @@ -730,16 +799,16 @@ //! 2. Setup expected result. //! 3. Create single transfer test and run test //! -//! @SYMTestExpectedResults +//! TestExpectedResults //! //! 1. TransfeArgs set up in DMA framework //! 2. Expected results set up in DMA framework //! 3. Fragment request completes and KErrNone returned //! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented +//! TestPriority High +//! TestStatus Implemented //---------------------------------------------------------------------------------------------- -namespace TestNewStyleFragment_4 +namespace Fragment_3 { const TInt srcAddr = 32 * KKilo; const TInt desAddr = 64 * KKilo; @@ -749,17 +818,18 @@ const TRequestResults requestResult(KErrNone, 1); const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); - CSingleTransferTest testscenario_4(_L("TestNewStyleFragment - Test Scenario 4"), 1, transferArgs, expectedResults); + CMultiVersionTest multiVersion(new (ELeave) CSingleTransferTest(_L("Fragment - Scenario 4"), 1, transferArgs, expectedResults)); - TTestCase testCase(&testscenario_4, EFalse, capAboveV1); - TTestCase testCaseConcurrent(&testscenario_4, ETrue, capAboveV1); + TTestCase testCase(&multiVersion, EFalse); + TTestCase testCaseConcurrent(&multiVersion, ETrue); } //---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2560 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc TestNewStyleFragment using CSingleTransferTest +//! 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. @@ -772,18 +842,17 @@ //! 2. Setup expected result. //! 3. Create single transfer test and run test //! -//! @SYMTestExpectedResults +//! TestExpectedResults //! //! 1. TransfeArgs set up in DMA framework //! 2. Expected results set up in DMA framework //! 3. Fragment request completes and KErrNone returned //! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented +//! TestPriority High +//! TestStatus Implemented //---------------------------------------------------------------------------------------------- -namespace TestNewStyleFragment_5 +namespace Fragment_4 { - const TInt srcAddr = 16 * KKilo; const TInt desAddr = 2 * KMega; const TInt transferSize = 1 * KMega; @@ -792,17 +861,18 @@ const TRequestResults requestResult(KErrNone); const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); - CSingleTransferTest testscenario_5(_L("TestNewStyleFragment - Test Scenario 5"), 1, transferArgs, expectedResults); + CMultiVersionTest multiVersion(new (ELeave) CSingleTransferTest(_L("Fragment - Scenario 5"), 1, transferArgs, expectedResults)); - TTestCase testCase(&testscenario_5, EFalse, capAboveV1); - TTestCase testCaseConcurrent(&testscenario_5, ETrue, capAboveV1); + TTestCase testCase(&multiVersion, EFalse); + TTestCase testCaseConcurrent(&multiVersion, ETrue); } //---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2560 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc TestNewStyleFragment using CSingleTransferTest +//! 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. @@ -815,451 +885,122 @@ //! 2. Setup expected result. //! 3. Create single transfer test and run test //! -//! @SYMTestExpectedResults +//! TestExpectedResults //! //! 1. TransfeArgs set up in DMA framework //! 2. Expected results set up in DMA framework //! 3. Fragment request completes and KErrNone returned //! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented +//! TestPriority High +//! TestStatus Implemented //---------------------------------------------------------------------------------------------- -namespace TestNewStyleFragment_6 +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 TRequestResults requestResult(KErrNone); const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); - CSingleTransferTest testscenario_6(_L("TestNewStyleFragment - Test Scenario 6"), 1, transferArgs, expectedResults); + CMultiVersionTest multiVersion(new (ELeave) CSingleTransferTest(_L("Fragment - Scenario 6"), 1, transferArgs, expectedResults)); - TTestCase testCase(&testscenario_6, EFalse, capAboveV1); - TTestCase testCaseConcurrent(&testscenario_6, ETrue, capAboveV1); + TTestCase testCase(&multiVersion, EFalse); + TTestCase testCaseConcurrent(&multiVersion, ETrue); } -//---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2561 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc TestOldstyleFragment using CSingleTransferTest -//! Test Scenario 1 - DstAddr > SrcAddr & TransferSize=32K & Location is -//! address of a memory buffer -//! -//! 1. Set up the arguments for aTransfeArgs using the settings below. -//! -//! SrcAddr = 4 * KKilo; -//! desAddr = 64 * KKilo; -//! transferSize = 32 * KKilo; -//! iFlags = KDmaMemAddr; - -//! 2. Setup expected result. -//! 3. Create single transfer test and run test -//! -//! @SYMTestExpectedResults -//! -//! 1. TransfeArgs set up in DMA framework -//! 2. Expected results set up in DMA framework -//! 3. Fragment request completes and KErrNone returned -//! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented -//---------------------------------------------------------------------------------------------- -namespace TestOldStyleFragment_1 - { - const TInt srcAddr = 4 * KKilo; - const TInt desAddr = 64 * KKilo; - const TInt transferSize = 32 * KKilo; - - TDmaTransferArgs transferArgs( srcAddr, desAddr, transferSize, KDmaMemAddr); - - const TRequestResults requestResult(KErrNone,32); - const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); - - CSingleTransferTest testscenario_1 = CSingleTransferTest(_L("TestOldStyleFragment - Test Scenario 1"), 1, transferArgs, expectedResults,KKilo). - UseNewDmaApi(EFalse); - - TTestCase testCase(&testscenario_1, EFalse, capAboveV1); - TTestCase testCaseConcurrent(&testscenario_1, ETrue, capAboveV1); - } //---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2561 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc TestOldstyleFragment using CSingleTransferTest -//! Test Scenario 2 - DstAddr == SrcAddr -//! -//! 1. Set up the arguments for aTransfeArgs using the settings below. -//! -//! SrcAddr = 4 * KKilo; -//! desAddr = 4 * KKilo; -//! transferSize = 4 * KKilo -//! iFlags = KDmaMemAddr; -//! -//! 2. Setup expected result. -//! 3. Create single transfer test and run test -//! -//! @SYMTestExpectedResults -//! -//! 1. TransfeArgs set up in DMA framework -//! 2. Expected results set up in DMA framework -//! 3. Fragment passes and KErrNone returned +//! 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 //! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented -//---------------------------------------------------------------------------------------------- -namespace TestOldStyleFragment_2 - { - const TInt srcAddr = 4 * KKilo; - const TInt desAddr = 4 * KKilo; - const TInt transferSize = 4 * KKilo; - - TDmaTransferArgs transferArgs(srcAddr,desAddr, transferSize, KDmaMemAddr); - const TRequestResults requestResult(KErrNone, 4); - const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); - - CSingleTransferTest testscenario_2 = CSingleTransferTest(_L("TestOldStyleFragment - Test Scenario 2"), 1, transferArgs, expectedResults,KKilo) - .UseNewDmaApi(EFalse); - - TTestCase testCase(&testscenario_2, EFalse, capAboveV1); - TTestCase testCaseConcurrent(&testscenario_2, ETrue, capAboveV1); - } - -//---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2561 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc TestOldstyleFragment using CSingleTransferTest -//! Test Scenario 3 - TransferSize=0 -//! -//! 1. Set up the arguments for aTransfeArgs using the settings below. -//! -//! SrcAddr = 32K -//! desAddr = 64K; -//! transferSize = 0 -//! iFlags = KDmaMemAddr; -//! +//! 1. Set up the DDmaRequest using aMaxTransferSize set to 0. //! 2. Setup expected result. //! 3. Create single transfer test and run test //! -//! @SYMTestExpectedResults -//! -//! 1. TransfeArgs set up in DMA framework -//! 2. Expected results set up in DMA framework -//! 3. Fragment request Fails and KErrArgument returned -//! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented -//---------------------------------------------------------------------------------------------- -namespace TestOldStyleFragment_3 - { - - const TInt srcAddr = 32 * KKilo; - const TInt desAddr = 64 * KKilo; - const TInt transferSize = 0; - - TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize,KDmaMemAddr); - const TRequestResults requestResult(KErrArgument, 0); - const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); - - CSingleTransferTest testscenario_3 = CSingleTransferTest(_L("TestOldStyleFragment - Test Scenario 3"), 1, transferArgs, expectedResults). - UseNewDmaApi(EFalse); - - TTestCase testCase(&testscenario_3, EFalse, capAboveV1); - TTestCase testCaseConcurrent(&testscenario_3, ETrue, capAboveV1); - } - -//---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2561 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc TestOldstyleFragment using CSingleTransferTest -//! Test Scenario 4 - TransferSize=1Byte -//! -//! 1. Set up the arguments for aTransfeArgs using the settings below. -//! -//! -//! SrcAddr = 32K; -//! desAddr = 64K; -//! transferSize = 1 byte -//! iFlags = KDmaMemAddr; -//! -//! 2. Setup expected result. -//! 3. Create single transfer test and run test -//! -//! @SYMTestExpectedResults +//! TestExpectedResults //! //! 1. TransfeArgs set up in DMA framework -//! 2. Expected results set up in DMA framework -//! 3. Fragment request completes and KErrNone returned -//! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented -//------------------------------------------------------------------------------------------------ -namespace TestOldStyleFragment_4 - { - const TInt srcAddr = 32 * KKilo; - const TInt desAddr = 64 * KKilo; - const TInt transferSize = 1; - - TDmaTransferArgs transferArgs( srcAddr, desAddr, transferSize, KDmaMemAddr); - const TRequestResults requestResult(KErrNone, 1); - const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); - - CSingleTransferTest testscenario_4 = CSingleTransferTest(_L("TestOldStyleFragment - Test Scenario 4"), 1, transferArgs, expectedResults). - UseNewDmaApi(EFalse); - - TTestCase testCase(&testscenario_4, EFalse, capAboveV1); - TTestCase testCaseConcurrent(&testscenario_4, ETrue, capAboveV1); - } - -//---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2561 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc TestOldstyleFragment using CSingleTransferTest -//! Test Scenario 5 - TransferSize=1MB -//! -//! 1. Set up the arguments for aTransfeArgs using the settings below. -//! -//! SrcAddr = 16K; -//! desAddr = 2MB; -//! transferSize = 1MB -//! iFlags = KDmaMemAddr; -//! -//! 2. Setup expected result. -//! 3. Create single transfer test and run test -//! -//! @SYMTestExpectedResults -//! -//! 1. TransfeArgs set up in DMA framework -//! 2. Expected results set up in DMA framework -//! 3. Fragment request completes and KErrNone returned -//! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented -//---------------------------------------------------------------------------------------------- -namespace TestOldStyleFragment_5 - { - const TInt srcAddr = 16 * KKilo; - const TInt desAddr = 2 * KMega; - const TInt transferSize = 1 * KMega; - - TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize, KDmaMemAddr); - - const TRequestResults requestResult(KErrNone); - const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); - - CSingleTransferTest testscenario_5 = CSingleTransferTest(_L("TestOldStyleFragment - Test Scenario 5"), 1, transferArgs, expectedResults). - UseNewDmaApi(EFalse); - - TTestCase testCase(&testscenario_5, EFalse, capAboveV1); - TTestCase testCaseConcurrent(&testscenario_5, ETrue, capAboveV1); - } - -//---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2561 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc TestOldstyleFragment using CSingleTransferTest -//! Test Scenario 6 - TransferSize=3MB -//! -//! 1. Set up the arguments for aTransfeArgs using the settings below. -//! -//! SrcAddr = 16K -//! desAddr = 4MB; -//! transferSize = 3MB -//! iFlags = KDmaMemAddr; -//! -//! 2. Setup expected result. -//! 3. Create single transfer test and run test -//! -//! @SYMTestExpectedResults -//! -//! 1. TransfeArgs set up in DMA framework -//! 2. Expected results set up in DMA framework -//! 3. Fragment request completes and KErrNone returned -//! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented -//---------------------------------------------------------------------------------------------- -namespace TestOldStyleFragment_6 - { - const TInt srcAddr = 16 * KKilo; - const TInt desAddr = 4 * KMega; - const TInt transferSize = 3 * KMega; - TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize, KDmaMemAddr); - - const TRequestResults requestResult(KErrNone); - const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); - - CSingleTransferTest testscenario_6 = CSingleTransferTest(_L("TestOldStyleFragment - Test Scenario 6"), 1, transferArgs, expectedResults). - UseNewDmaApi(EFalse); - - TTestCase testCase(&testscenario_6, EFalse, capAboveV1); - TTestCase testCaseConcurrent(&testscenario_6, ETrue, capAboveV1); - } - -//---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2562 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc TestOldStyleDDmaRequest using CSingleTransferTest -//! Test Scenario 1 - aMaxTransferSize=0 -//! -//! 1. Set up the DDmaRequest using aMaxTransferSize set to 0. -//! 2. Setup expected result. -//! 3. Create single transfer test and run test -//! -//! @SYMTestExpectedResults -//! -//! 1. TransfeArgs set up in DMA framework -//! 2. Expected results set up in DMA framework +//! 2. Expected results set up in DMA framework //! 3. DDmaRequest constructor behaves as expected and KErrArgument returned //! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented +//! TestPriority High +//! TestStatus Implemented //------------------------------------------------------------------------------------------------ -namespace TestOldStyleDDmaRequest_1 +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 TRequestResults requestResult(KErrNone, 0); const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); - CSingleTransferTest testscenario_1 = CSingleTransferTest(_L("TestOldStyleDDmaRequest - Test Scenario 1"), 1, transferArgs, expectedResults,0). - UseNewDmaApi(EFalse); + CMultiVersionTest multiVersion(new (ELeave) CSingleTransferTest(_L("DDmaRequest - Scenario 1"), 1, transferArgs, expectedResults,0)); - TTestCase testCase(&testscenario_1, EFalse, capAboveV1); - TTestCase testCaseConcurrent(&testscenario_1, ETrue, capAboveV1); + TTestCase testCase(&multiVersion, EFalse); + TTestCase testCaseConcurrent(&multiVersion, ETrue); } //!------------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2562 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc TestOldStyleDDmaRequest using CSingleTransferTest -//! Test Scenario 2 - aMaxTransferSize= 65535 +//! 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 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 //! -//! @SYMTestExpectedResults +//! TestExpectedResults //! //! 1. TransfeArgs set up in DMA framework -//! 2. Expected results set up in DMA framework +//! 2. Expected results set up in DMA framework //! 3. DDmaRequest constructor behaves as expected and KErrArgument returned //! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented +//! TestPriority High +//! TestStatus Implemented //--------------------------------------------------------------------------------------------------- -namespace TestOldStyleDDmaRequest_2 +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 TRequestResults requestResult(KErrNone, 1); const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); - CSingleTransferTest testscenario_2 = CSingleTransferTest(_L("TestOldStyleDDmaRequest - Test Scenario 2"), 1, transferArgs, expectedResults, 65535). - UseNewDmaApi(EFalse); + CMultiVersionTest multiVersion(new (ELeave) CSingleTransferTest(_L("DDmaRequest - Scenario 2"), 1, transferArgs, expectedResults, trans64K_1)); - TTestCase testCase(&testscenario_2, EFalse, capAboveV1); - TTestCase testCaseConcurrent(&testscenario_2, ETrue, capAboveV1); + TTestCase testCase(&multiVersion, EFalse); + TTestCase testCaseConcurrent(&multiVersion, ETrue); } //---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2563 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc TestNewStyleDDmaRequest using CSingleTransferTest -//! Test Scenario 1 - aMaxTransferSize=0 -//! -//! 1. Set up the DDmaRequest using aMaxTransferSize set to 0. -//! 2. Setup expected result. -//! 3. Create single transfer test and run test -//! -//! @SYMTestExpectedResults -//! -//! 1. TransfeArgs set up in DMA framework -//! 2. Expected results set up in DMA framework -//! 3. DDmaRequest constructor behaves as expected and KErrArgument returned -//! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented -//---------------------------------------------------------------------------------------------- -namespace TestNewStyleDDmaRequest_1 - { - const TInt desAddr = 4 * KKilo; - const TInt transferSize = 4 * KKilo; - TDmaTransferArgs transferArgs(0, desAddr, transferSize, KDmaMemAddr); - - const TRequestResults requestResult(KErrNone, 0); - const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); - - CSingleTransferTest testscenario_1(_L("TestNewStyleDDmaRequest - Test Scenario 1"), 1, transferArgs, expectedResults,0); - - TTestCase testCase(&testscenario_1, EFalse, capAboveV1); - TTestCase testCaseConcurrent(&testscenario_1, ETrue, capAboveV1); - } - -//!------------------------------------------------------------------------------------------------- -//! @SYMTestCaseID KBASE-DMA-2563 -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc TestNewStyleDDmaRequest using CSingleTransferTest -//! Test Scenario 2 - aMaxTransferSize= 65535 -//! -//! 1. Set up the arguments for DDmaRequest using aMaxTransferSize set to 65535. -//! 2. Setup expected result. -//! 3. Create single transfer test and run test -//! -//! @SYMTestExpectedResults -//! -//! 1. TransfeArgs set up in DMA framework -//! 2. Expected results set up in DMA framework -//! 3. DDmaRequest constructor behaves as expected and KErrArgument returned -//! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented -//--------------------------------------------------------------------------------------------------- -namespace TestNewStyleDDmaRequest_2 - { - const TInt desAddr = 4 * KKilo; - const TInt transferSize = 4 * KKilo; - TDmaTransferArgs transferArgs(0, desAddr, transferSize, KDmaMemAddr); - - const TRequestResults requestResult(KErrNone, 1); - const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); - - CSingleTransferTest testscenario_2(_L("TestNewStyleDDmaRequest - Test Scenario 2"), 1, transferArgs, expectedResults, 65535); - - TTestCase testCase(&testscenario_2, EFalse, capAboveV1); - TTestCase testCaseConcurrent(&testscenario_2, ETrue, capAboveV1); - } - -//---------------------------------------------------------------------------------------------- -//! @SYMTestCaseID PBASE-DMA-FUNC-xxx -//! @SYMTestType CIT -//! @SYMPREQ REQ -//! @SYMTestCaseDesc SmallFrags: This test provokes the failure seen in DEF140598 +//! 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 //! -//! @SYMTestExpectedResults +//! TestActions +//! 1. Open a DMA channel for a transfer. +//! 2. Create single transfer test using small frags and run test //! -//! 1. -//! 2. +//! TestExpectedResults +//! 1. DMA channel opens and KErrNone returned. +//! 2. DMA transfer completes with no errors. //! -//! @SYMTestPriority High -//! @SYMTestStatus Implemented +//! TestPriority High +//! TestStatus Implemented //---------------------------------------------------------------------------------------------- namespace SmallFrags { @@ -1269,19 +1010,205 @@ const TResultSet expectedResults(threadCallback); TTestCase testCase( - new (ELeave) CSingleTransferTest(_L("8 * 4byte frags"), 10, transferArgs, expectedResults, 4), - EFalse, capAboveV1); + 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); } -//TODO TTestCase could automatically be added to aray by ctor -// +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, +}; + +static TTestCase* StaticQueueTestArray[] = { + &CancelAllTest::testCase, + &IsQueueEmptyTest::testCase, +}; + //Append new test cases here static TTestCase* StaticTestArray[] = { &Simple_1::testCase, - &Simple_1::testCaseConcurrent, - &Simple_2::testCase, - &Simple_2::testCaseConcurrent, + &Simple_1::testCaseConcurrent, &Callback::testCase, &Callback::testCaseOldRequest, &ISR_Reque::endOnRedo::testCase, @@ -1291,62 +1218,67 @@ #ifdef _DEBUG &ISR_Reque::invalidAddresses::testCase, // addresses only checked in UDEB #endif - //&ISR_Reque::multipleFragments::testCase, // This error condition is currently caught by a FAULT instead of a return code +#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::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::Transfer::_4MB::testCase, &Benchmark::CompareIsrDfcCb::Dfc::_4Bytes::testCase, &Benchmark::CompareIsrDfcCb::Isr::_4Bytes::testCase, &Benchmark::CompareIsrDfcCb::Dfc::_4K::testCase, &Benchmark::CompareIsrDfcCb::Isr::_4K::testCase, #endif - &TestNewStyleFragment_1::testCase, - &TestNewStyleFragment_1::testCaseConcurrent, - &TestNewStyleFragment_2::testCase, - &TestNewStyleFragment_2::testCaseConcurrent, - //&TestNewStyleFragment_3::testCase, - //&TestNewStyleFragment_3::testCaseConcurrent, - &TestNewStyleFragment_4::testCase, - &TestNewStyleFragment_4::testCaseConcurrent, - &TestNewStyleFragment_5::testCase, - &TestNewStyleFragment_5::testCaseConcurrent, - &TestNewStyleFragment_6::testCase, - &TestNewStyleFragment_6::testCaseConcurrent, - &TestOldStyleFragment_1::testCase, - &TestOldStyleFragment_1::testCaseConcurrent, - &TestOldStyleFragment_2::testCase, - &TestOldStyleFragment_2::testCaseConcurrent, - //&TestOldStyleFragment_3::testCase, - //&TestOldStyleFragment_3::testCaseConcurrent, - &TestOldStyleFragment_4::testCase, - &TestOldStyleFragment_4::testCaseConcurrent, - &TestOldStyleFragment_5::testCase, - &TestOldStyleFragment_5::testCaseConcurrent, - &TestOldStyleFragment_6::testCase, - &TestOldStyleFragment_6::testCaseConcurrent, - &TestOldStyleDDmaRequest_1::testCase, - &TestOldStyleDDmaRequest_1::testCaseConcurrent, - &TestOldStyleDDmaRequest_2::testCase, - &TestOldStyleDDmaRequest_2::testCaseConcurrent, - &TestNewStyleDDmaRequest_1::testCase, - &TestNewStyleDDmaRequest_1::testCaseConcurrent, - &TestNewStyleDDmaRequest_2::testCase, - &TestNewStyleDDmaRequest_2::testCaseConcurrent, + &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, + &CancelAllTest::testCase, + &IsQueueEmptyTest::testCase, }; 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));