diff -r f497542af8e4 -r 538db54a451d kerneltest/e32test/dmav2/test_cases.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/kerneltest/e32test/dmav2/test_cases.cpp Mon Jan 18 21:31:10 2010 +0200 @@ -0,0 +1,1352 @@ +/* +* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* This file contains statically defined test cases, a pointer to each +* new test case should be entered in StaticTestArray +* +*/ + +#include "t_dma2.h" +#include "cap_reqs.h" + +const TCallbackRecord threadCallback(TCallbackRecord::EThread,1); +const TCallbackRecord isrCallback(TCallbackRecord::EIsr,1); + +const TInt size = 128 * KKilo; +//-------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2560 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc Simple DMA transfer test using CSingleTransferTest and New DMA APIs +//! +//! @SYMTestActions +//! 1. +//! 2. +//! +//! +//! @SYMTestExpectedResults +//! 1. +//! 2. +//! +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace Simple_1 + { + TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr); + + const TResultSet expectedResults(threadCallback); + + CSingleTransferTest simpleTest(_L("Simple Test - New DMA APIs"), 1, transferArgs, expectedResults); + + TTestCase testCase(&simpleTest, EFalse, capAboveV1); + TTestCase testCaseConcurrent(&simpleTest, ETrue, capAboveV1); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2561 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc Simple DMA transfer test using CSingleTransferTest and OLD DMA APIs +//! +//! @SYMTestActions +//! 1. +//! 2. +//! +//! +//! @SYMTestExpectedResults +//! 1. +//! 2. +//! +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace Simple_2 + { + TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr); + + const TResultSet expectedResults(threadCallback); + + CSingleTransferTest simpleTest = CSingleTransferTest(_L("Simple Test - Old DMA APIs"), 1, transferArgs, expectedResults, 0). + UseNewDmaApi(EFalse); + + TTestCase testCase(&simpleTest, EFalse); + TTestCase testCaseConcurrent(&simpleTest, ETrue); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2573 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc DMA ISR Callback test (Isr Callback - use old request Ctor) +//! +//! @SYMTestActions +//! 1. +//! 2. +//! +//! +//! @SYMTestExpectedResults +//! 1. +//! 2. +//! +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace Callback + { + TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr); + + const TResultSet expectedResults(isrCallback); + + CSingleTransferTest isrTest(_L("Isr Callback"), 1, transferArgs, expectedResults); + TTestCase testCase(&isrTest, EFalse, capAboveV1); + + + const TRequestResults fragmentFails = TRequestResults(). + FragmentationResult(KErrArgument). + QueueResult(KErrUnknown); + + const TResultSet expectedResultsFail = TResultSet(EFalse). + ChannelOpenResult(KErrNone). + RequestResult(fragmentFails). + PostTransferResult(1); // PostTransferResult of 1 means buffers don't match + + CSingleTransferTest isrTestOldRequest = CSingleTransferTest(_L("Isr Callback - use old request Ctor"), 1, transferArgs, expectedResultsFail) + .UseNewRequest(EFalse); + TTestCase testCaseOldRequest(&isrTestOldRequest, EFalse, capAboveV1); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2574,KBASE-DMA-2575 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc DMA ISR Reque test +//! +//! @SYMTestActions +//! 1. +//! 2. +//! +//! +//! @SYMTestExpectedResults +//! 1. +//! 2. +//! +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace ISR_Reque + { + const TInt size = 4 * KKilo; + TDmaTransferArgs tferArgs(0, 2*size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr); + + const TRequestResults requestResult(KErrNone, 1); // request must be in a single fragment + + namespace endOnIsrCb + { + TIsrRequeArgs requeArgs[] = { + TIsrRequeArgs(), + TIsrRequeArgs(size,3*size,size,0, ETrue), + TIsrRequeArgs(size,4*size,size,0, ETrue), + TIsrRequeArgs(0,5*size,size,0, ETrue), + }; + const TInt count = ARRAY_LENGTH(requeArgs); + + // we expect a cb for each requeue + 1 for the original + // transfer + const TCallbackRecord callbackRecord = TCallbackRecord(TCallbackRecord::EIsr, count + 1).IsrRedoResult(KErrNone); + const TResultSet expected(KErrNone, requestResult, KErrNone, callbackRecord); + + TTestCase testCase(new (ELeave) CIsrRequeTest(_L("4 Requeues - end on isr cb"), 1, tferArgs, requeArgs, count, expected, &KPreTransferIncrBytes, &KCompareSrcDst), ETrue, capAboveV1); + } + + namespace endOnThreadCb + { + TIsrRequeArgs requeArgs[] = { + TIsrRequeArgs(), + TIsrRequeArgs(size,3*size,size,0, ETrue), + TIsrRequeArgs(size,4*size,size,0, ETrue), + TIsrRequeArgs(0,5*size,size,0, EFalse), + }; + const TInt count = ARRAY_LENGTH(requeArgs); + + const TCallbackRecord callbackRecord = TCallbackRecord(TCallbackRecord::EThread, count + 1).IsrRedoResult(KErrNone); + const TResultSet expected(KErrNone, requestResult, KErrNone, callbackRecord); + + TTestCase testCase(new (ELeave) CIsrRequeTest(_L("4 Requeues - end on thread cb"), 1, tferArgs, requeArgs, count, expected, &KPreTransferIncrBytes, &KCompareSrcDst), ETrue, capAboveV1); + } + + namespace changeSize + { + TIsrRequeArgs requeArgs[] = { + TIsrRequeArgs(3*size,5*size,2*size,0, EFalse), + }; + const TInt count = ARRAY_LENGTH(requeArgs); + + const TCallbackRecord callbackRecord = TCallbackRecord(TCallbackRecord::EThread, count + 1).IsrRedoResult(KErrNone); + const TResultSet expected(KErrNone, requestResult, KErrNone, callbackRecord); + + TTestCase testCase(new (ELeave) CIsrRequeTest(_L("1 Requeues - change transfer size"), 1, tferArgs, requeArgs, count, expected, &KPreTransferIncrBytes, &KCompareSrcDst), ETrue, capAboveV1); + } + + namespace endOnRedo + { + // TODO have made this bigger than 4k so that we don't miss the second interrupt when tracing enabled + // this indicates the PSL's interrupt handler misses an interrupt if it occurs during the interrupt. + const TInt size = 0x10000; + TDmaTransferArgs tferArgs(0, 2*size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr); + + TIsrRequeArgs requeArgs[] = { + TIsrRequeArgs(3*size,5*size,2*size,0, ETrue), + TIsrRequeArgs() //repeat the previous transfer + }; + const TInt count = ARRAY_LENGTH(requeArgs); + + const TCallbackRecord callbackRecord = TCallbackRecord(TCallbackRecord::EIsr, count + 1).IsrRedoResult(KErrNone); + const TResultSet expected(KErrNone, requestResult, KErrNone, callbackRecord); + + TTestCase testCase(new (ELeave) CIsrRequeTest(_L("2 Requeues - Isr redo request repeated"), 1, tferArgs, requeArgs, count, expected, &KPreTransferIncrBytes, &KCompareSrcDst), EFalse, capAboveV1); + } + + namespace invalidAddresses + { + TIsrRequeArgs requeArgs[] = { + TIsrRequeArgs(size, size) + }; + const TInt count = ARRAY_LENGTH(requeArgs); + + const TCallbackRecord callbackRecord = TCallbackRecord(TCallbackRecord::EIsr, 1).IsrRedoResult(KErrArgument); + const TResultSet expected(KErrNone, requestResult, KErrUnknown, callbackRecord); + + // pre and post test would fail because of bad requeue parameters + TTestCase testCase(new (ELeave) CIsrRequeTest(_L("Requeue with matching addresses"), 1, tferArgs, requeArgs, count, expected, NULL, NULL), ETrue, capAboveV1); + } + + namespace multipleFragments + { + TIsrRequeArgs requeArgs[] = { + TIsrRequeArgs() + }; + const TInt count = ARRAY_LENGTH(requeArgs); + + const TCallbackRecord callbackRecord = TCallbackRecord(TCallbackRecord::EThread, count + 1).IsrRedoResult(KErrNone); + + TRequestResults results2Fragments = TRequestResults(requestResult).FragmentCount(2); + const TResultSet expected(KErrNone, results2Fragments, KErrNone, callbackRecord); + + TTestCase testCase(new (ELeave) CIsrRequeTest(_L("Attempt to Requeue 2 fragment request"), 1, tferArgs, requeArgs, count, expected, &KPreTransferIncrBytes, &KCompareSrcDst, size/2), ETrue, capAboveV1); + + } + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID PBASE-DMA-FUNC-xxx +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc DMA Multiple transfer test +//! @SYMTestActions +//! 1. +//! 2. +//! +//! +//! @SYMTestExpectedResults +//! 1. +//! 2. +//! +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace Multipart + { + // need long transfer, to try and force adjacent + // requests to be concatinated + const TInt size = 2 * KMega; + const TDmaTransferArgs transferArgArray[] = { + TDmaTransferArgs(0, size, size, KDmaMemAddr), + TDmaTransferArgs(size, 2 * size, size, KDmaMemAddr) + }; + + const TResultSet expected[] = + { + TResultSet(), + TResultSet() + }; + const TResultSet expectedResults(isrCallback); + + CMultiTransferTest multipart = + CMultiTransferTest(_L("Sg request concatination"), 1, transferArgArray, expected, ARRAY_LENGTH(transferArgArray)) + .SetPreTransferTest(&KPreTransferIncrBytes) + .SetPostTransferTest(&KCompareSrcDst); + + TTestCase testCase(&multipart, EFalse, hwDesWanted_skip); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2580 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc These tests attempt to queue ISR cb requests while the queue is not +//! empty and queing normal requests when an ISR cb is pending +//! @SYMTestActions +//! 1. +//! 2. +//! +//! +//! @SYMTestExpectedResults +//! 1. +//! 2. +//! +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace IsrAndDfc + { + // need long transfer, so that 1st request is still queued + // when the second one is queued + // TODO pause is the better way to ensure this + //const TInt size = 2 * KMega; + //TODO have changed size to ensure that the first isr callback request in IsrBeforeDfc + //will only have one fragment + const TInt size = 0x40000; + TDmaTransferArgs dfcTransfer(0, size, size, KDmaMemAddr); + TDmaTransferArgs isrTransfer(size, 2 * size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr); + + const TResultSet success = TResultSet(); + TResultSet queueFailure = TResultSet(). + RequestResult(TRequestResults().QueueResult(KErrGeneral)). + CallbackRecord(TCallbackRecord::Empty()). + PostTransferResult(1); + + namespace DfcBeforeIsr + { + const TDmaTransferArgs transferArgArray[] = { + dfcTransfer, + isrTransfer + }; + + const TResultSet expected[] = + { + success, + queueFailure + }; + CMultiTransferTest dfcBeforeIsr = + CMultiTransferTest(_L("DFC cb req before ISR cb req "), 1, transferArgArray, expected, ARRAY_LENGTH(transferArgArray)) + .SetPreTransferTest(&KPreTransferIncrBytes) + .SetPostTransferTest(&KCompareSrcDst); + TTestCase testCase(&dfcBeforeIsr, EFalse, hwDesWanted_skip); + } + + namespace IsrBeforeDfc + { + const TDmaTransferArgs transferArgArray[] = { + isrTransfer, + dfcTransfer + }; + + TResultSet isrSuccess = TResultSet(success).CallbackRecord(isrCallback); + const TResultSet expected[] = + { + isrSuccess, + queueFailure + }; + CMultiTransferTest dfcBeforeIsr = + CMultiTransferTest(_L("ISR cb req before DFC cb req "), 1, transferArgArray, expected, ARRAY_LENGTH(transferArgArray)) + .SetPreTransferTest(&KPreTransferIncrBytes) + .SetPostTransferTest(&KCompareSrcDst); + TTestCase testCase(&dfcBeforeIsr, EFalse, hwDesWanted_skip); + } + + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID PBASE-DMA-FUNC-xxx +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc DMA 2D transfer test +//! +//! @SYMTestActions +//! 1. +//! 2. +//! +//! +//! @SYMTestExpectedResults +//! 1. +//! 2. +//! +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace _2D_Test + { + // Image @ 0x0 with 640x480 pixels and 24 bits/pixel. + + TDmaTransferConfig src( + 0, /*iAddr*/ + 3, /*iElementSize*/ + 6, /*iElementsPerFrame*/ + 4, /*iFramesPerTransfer*/ + 0, /*iElementSkip*/ + 0, /*iFrameSkip*/ + KDmaMemAddr /*iFlags*/ + ); + + TDmaTransferConfig dst( + 0x708000, /*iAddr*/ + 3, /*iElementSize*/ + 640, /*iElementsPerFrame*/ + 480, /*iFramesPerTransfer*/ + 1437, /*iElementSkip*/ + -920166, /*iFrameSkip*/ + KDmaMemAddr /*iFlags*/ + ); + + TDmaTransferArgs transferArgs2D(src, dst); + + TResultSet expectedResults; //all KErrNone + + //source buffer is currently filled with increasing values + //instead of an image, but the test is still valid + CSingleTransferTest transfer2d(_L("2D Transfer"), 1, transferArgs2D, expectedResults, 0, &KCompare2D); + + TTestCase testCase2d(&transfer2d, EFalse, cap_2DRequired, capAboveV1); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2565 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc DMA Fragmentation count test +//! +//! @SYMTestActions +//! 1. +//! 2. +//! +//! +//! @SYMTestExpectedResults +//! 1. +//! 2. +//! +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace FragmentationCount + { + TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr); + + const TRequestResults requestResult(KErrNone, 128); + const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); + CSingleTransferTest test1(_L("Fragmentation Count - 128 fragments"), 1, transferArgs, expectedResults, KKilo); + TTestCase testCase(&test1, EFalse); + + const TRequestResults requestResult2(KErrNone, 4); + const TResultSet expectedResults2(KErrNone, requestResult2, KErrNone, threadCallback); + CSingleTransferTest test2(_L("Fragmentation Count - 4 fragments"), 1, transferArgs, expectedResults2, 32*KKilo); + TTestCase testCase2(&test2, EFalse); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2584,KBASE-DMA-2585 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc DMA Benchmark tests +//! +//! @SYMTestActions +//! 1. +//! 2. +//! +//! +//! @SYMTestExpectedResults +//! 1. +//! 2. +//! +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//----------------------------------------------------------------------------------------------- +namespace Benchmark + { + const TInt bmIters = 10; + namespace Frag + { + const TInt size = 1 * KMega; + TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr); + + TTestCase testCase_256k(new (ELeave) CDmaBmFragmentation(_L("1 Mb transfer - 256k frag size"), bmIters, transferArgs, 256 * KKilo), EFalse); + TTestCase testCase_8k(new (ELeave) CDmaBmFragmentation(_L("1 Mb transfer - 8k frag size"), bmIters, transferArgs, 8 * KKilo), EFalse); + } + + namespace Transfer + { + namespace _4Bytes + { + const TInt size = 4; + TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr); + + CDmaBmTransfer bmTest(_L("4 bytes"), bmIters, transferArgs, 0); + TTestCase testCase(&bmTest, EFalse); + } + namespace _128K + { + const TInt size = 128 * KKilo; + TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr); + + TTestCase testCase_128(new (ELeave) CDmaBmTransfer(_L("128 K - 128K frag size"), bmIters, transferArgs, 128 * KKilo), EFalse); + TTestCase testCase_16(new (ELeave) CDmaBmTransfer(_L("128 K - 16k frag size"), bmIters, transferArgs, 16 * KKilo), EFalse); + TTestCase testCase_4(new (ELeave) CDmaBmTransfer(_L("128 K - 4k frag size"), bmIters, transferArgs, 4 * KKilo), EFalse); + TTestCase testCase_1(new (ELeave) CDmaBmTransfer(_L("128 K - 1k frag size"), bmIters, transferArgs, 1 * KKilo), EFalse); + } + namespace _4Mb + { + const TInt size = 4 * KMega; + TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr); + + CDmaBmTransfer bmTest(_L("4 Mb"), bmIters, transferArgs, 0); + TTestCase testCase(&bmTest, EFalse); + } + } + + /** + Compare time taken between queing and callback of 4 byte + request with both DFC and ISR callback + The new API calls are used + */ + namespace CompareIsrDfcCb + { + const TInt iterations = 50; + + namespace Dfc + { + TResultSet expected = TResultSet(threadCallback). + PostTransferResult(KErrUnknown); + + namespace _4Bytes + { + const TInt size = 4; + TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr); + CDmaBmTransfer bmTest = CDmaBmTransfer(_L("4 bytes DFC cb"), iterations, transferArgs, 0). + UseNewDmaApi(ETrue). + ExpectedResults(expected); + TTestCase testCase(&bmTest, EFalse); + } + namespace _4K + { + const TInt size = 4 * KKilo; + TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr); + CDmaBmTransfer bmTest = CDmaBmTransfer(_L("4K DFC cb"), iterations, transferArgs, 0). + UseNewDmaApi(ETrue). + ExpectedResults(expected); + TTestCase testCase(&bmTest, EFalse); + } + } + + namespace Isr + { + TResultSet expected = TResultSet(isrCallback). + PostTransferResult(KErrUnknown); + + namespace _4Bytes + { + const TInt size = 4; + TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr); + CDmaBmTransfer bmTest = CDmaBmTransfer(_L("4 bytes Isr cb"), iterations, transferArgs, 0). + UseNewDmaApi(ETrue). + ExpectedResults(expected); + TTestCase testCase(&bmTest, EFalse); + } + namespace _4K + { + const TInt size = 4 * KKilo; + TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr); + CDmaBmTransfer bmTest = CDmaBmTransfer(_L("4K Isr cb"), iterations, transferArgs, 0). + UseNewDmaApi(ETrue). + ExpectedResults(expected); + TTestCase testCase(&bmTest, EFalse); + } + } + } + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2560 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc TestNewStyleFragment using CSingleTransferTest +//! Test Scenario 1 - DstAddr > SrcAddr & TransferSize=32K & Location is +//! address of a memory buffer +//! @SYMTestActions +//! 1. Set up the arguments for aTransfeArgs using the settings below. +//! +//! SrcAddr = 4 * KKilo; +//! desAddr = 64 * KKilo; +//! transferSize = 32 * KKilo; +//! iFlags = KDmaMemAddr; +//! +//! 2. Setup expected result. +//! 3. Create single transfer test and run test +//! +//! @SYMTestExpectedResults +//! 1. TransfeArgs set up in DMA framework +//! 2. Expected results set up in DMA framework +//! 3. Fragment request completes and KErrNone returned +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace TestNewStyleFragment_1 + { + const TInt srcAddr = 4 * KKilo; + const TInt desAddr = 64 * KKilo; + + const TInt transferSize = 32 * KKilo; + + TDmaTransferArgs transferArgs( srcAddr, desAddr, transferSize, KDmaMemAddr); + + const TRequestResults requestResult(KErrNone, 32); + const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); + + CSingleTransferTest testscenario_1(_L("TestNewStyleFragment - Test Scenario 1"), 1, transferArgs, expectedResults,KKilo); + + TTestCase testCase(&testscenario_1, EFalse, capAboveV1); + TTestCase testCaseConcurrent(&testscenario_1, ETrue, capAboveV1); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2560 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc TestNewStyleFragment using CSingleTransferTest +//! Test Scenario 2 - SrcAddr == DstAddr +//! +//! 1. Set up the arguments for aTransfeArgs using the settings below. +//! +//! SrcAddr = 4 * KKilo; +//! desAddr = 4 * KKilo; +//! transferSize = 32 * KKilo; +//! iFlags = KDmaMemAddr; +//! +//! 2. Setup expected result. +//! 3. Create single transfer test and run test +//! +//! @SYMTestExpectedResults +//! +//! 1. TransfeArgs set up in DMA framework +//! 2. Expected results set up in DMA framework +//! 3. Fragment passes and KErrNone returned +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace TestNewStyleFragment_2 + { + const TInt srcAddr = 4 * KKilo; + const TInt desAddr = 4 * KKilo; + const TInt transferSize = 32 * KKilo; + + TDmaTransferArgs transferArgs(srcAddr,desAddr, transferSize, KDmaMemAddr); + const TRequestResults requestResult(KErrNone, 32); + const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); + + CSingleTransferTest testscenario_2(_L("TestNewStyleFragment - Test Scenario 2"), 1, transferArgs, expectedResults,KKilo); + + TTestCase testCase(&testscenario_2, EFalse, capAboveV1); + TTestCase testCaseConcurrent(&testscenario_2, ETrue, capAboveV1); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2560 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc TestNewStyleFragment using CSingleTransferTest +//! Test Scenario 3 - TransferSize=0 +//! +//! 1. Set up the arguments for aTransfeArgs using the settings below. +//! +//! SrcAddr = 32 * KKilo; +//! desAddr = 64 * KKilo; +//! transferSize = 0 +//! iFlags = KDmaMemAddr; +//! +//! 2. Setup expected result. +//! 3. Create single transfer test and run test +//! +//! +//! @SYMTestExpectedResults +//! +//! 1. TransfeArgs set up in DMA framework +//! 2. Expected results set up in DMA framework +//! 3. Fragment request fails and KErrArgument returned +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace TestNewStyleFragment_3 + { + const TInt srcAddr = 32 * KKilo; + const TInt desAddr = 64 * KKilo; + const TInt transferSize = 0; + + TDmaTransferArgs transferArgs( srcAddr, desAddr, transferSize,KDmaMemAddr); + const TRequestResults requestResult(KErrArgument, 0); + const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); + + CSingleTransferTest testscenario_3(_L("TestNewStyleFragment - Test Scenario 3"), 1, transferArgs, expectedResults); + + TTestCase testCase(&testscenario_3, EFalse, capAboveV1); + TTestCase testCaseConcurrent(&testscenario_3, ETrue, capAboveV1); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2560 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc TestNewStyleFragment using CSingleTransferTest +//! Test Scenario 4 - TransferSize=1Byte +//! +//! 1. Set up the arguments for aTransfeArgs using the settings below. +//! +//! SrcAddr = 32K; +//! desAddr = 64K; +//! transferSize = 1 byte +//! iFlags = KDmaMemAddr; +//! +//! 2. Setup expected result. +//! 3. Create single transfer test and run test +//! +//! @SYMTestExpectedResults +//! +//! 1. TransfeArgs set up in DMA framework +//! 2. Expected results set up in DMA framework +//! 3. Fragment request completes and KErrNone returned +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace TestNewStyleFragment_4 + { + const TInt srcAddr = 32 * KKilo; + const TInt desAddr = 64 * KKilo; + const TInt transferSize = 1; + + TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize, KDmaMemAddr); + const TRequestResults requestResult(KErrNone, 1); + const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); + + CSingleTransferTest testscenario_4(_L("TestNewStyleFragment - Test Scenario 4"), 1, transferArgs, expectedResults); + + TTestCase testCase(&testscenario_4, EFalse, capAboveV1); + TTestCase testCaseConcurrent(&testscenario_4, ETrue, capAboveV1); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2560 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc TestNewStyleFragment using CSingleTransferTest +//! Test Scenario 5 - TransferSize=128KB +//! +//! 1. Set up the arguments for aTransfeArgs using the settings below. +//! +//! SrcAddr = 16K; +//! desAddr = 2MB; +//! transferSize = 1MB; +//! iFlags = KDmaMemAddr; +//! +//! 2. Setup expected result. +//! 3. Create single transfer test and run test +//! +//! @SYMTestExpectedResults +//! +//! 1. TransfeArgs set up in DMA framework +//! 2. Expected results set up in DMA framework +//! 3. Fragment request completes and KErrNone returned +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace TestNewStyleFragment_5 + { + + const TInt srcAddr = 16 * KKilo; + const TInt desAddr = 2 * KMega; + const TInt transferSize = 1 * KMega; + + TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize, KDmaMemAddr); + const TRequestResults requestResult(KErrNone); + const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); + + CSingleTransferTest testscenario_5(_L("TestNewStyleFragment - Test Scenario 5"), 1, transferArgs, expectedResults); + + TTestCase testCase(&testscenario_5, EFalse, capAboveV1); + TTestCase testCaseConcurrent(&testscenario_5, ETrue, capAboveV1); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2560 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc TestNewStyleFragment using CSingleTransferTest +//! Test Scenario 6 - TransferSize=3MB +//! +//! 1. Set up the arguments for aTransfeArgs using the settings below. +//! +//! SrcAddr = 16K; +//! desAddr = 4MB; +//! transferSize = 3MB +//! iFlags = KDmaMemAddr; +//! +//! 2. Setup expected result. +//! 3. Create single transfer test and run test +//! +//! @SYMTestExpectedResults +//! +//! 1. TransfeArgs set up in DMA framework +//! 2. Expected results set up in DMA framework +//! 3. Fragment request completes and KErrNone returned +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace TestNewStyleFragment_6 + { + const TInt srcAddr = 16 * KKilo; + const TInt desAddr = 4 * KMega; + const TInt transferSize = 3 * KMega; + + TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize, KDmaMemAddr); + const TRequestResults requestResult(KErrNone); + const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); + + CSingleTransferTest testscenario_6(_L("TestNewStyleFragment - Test Scenario 6"), 1, transferArgs, expectedResults); + + TTestCase testCase(&testscenario_6, EFalse, capAboveV1); + TTestCase testCaseConcurrent(&testscenario_6, ETrue, capAboveV1); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2561 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc TestOldstyleFragment using CSingleTransferTest +//! Test Scenario 1 - DstAddr > SrcAddr & TransferSize=32K & Location is +//! address of a memory buffer +//! +//! 1. Set up the arguments for aTransfeArgs using the settings below. +//! +//! SrcAddr = 4 * KKilo; +//! desAddr = 64 * KKilo; +//! transferSize = 32 * KKilo; +//! iFlags = KDmaMemAddr; + +//! 2. Setup expected result. +//! 3. Create single transfer test and run test +//! +//! @SYMTestExpectedResults +//! +//! 1. TransfeArgs set up in DMA framework +//! 2. Expected results set up in DMA framework +//! 3. Fragment request completes and KErrNone returned +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace TestOldStyleFragment_1 + { + const TInt srcAddr = 4 * KKilo; + const TInt desAddr = 64 * KKilo; + const TInt transferSize = 32 * KKilo; + + TDmaTransferArgs transferArgs( srcAddr, desAddr, transferSize, KDmaMemAddr); + + const TRequestResults requestResult(KErrNone,32); + const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); + + CSingleTransferTest testscenario_1 = CSingleTransferTest(_L("TestOldStyleFragment - Test Scenario 1"), 1, transferArgs, expectedResults,KKilo). + UseNewDmaApi(EFalse); + + TTestCase testCase(&testscenario_1, EFalse, capAboveV1); + TTestCase testCaseConcurrent(&testscenario_1, ETrue, capAboveV1); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2561 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc TestOldstyleFragment using CSingleTransferTest +//! Test Scenario 2 - DstAddr == SrcAddr +//! +//! 1. Set up the arguments for aTransfeArgs using the settings below. +//! +//! SrcAddr = 4 * KKilo; +//! desAddr = 4 * KKilo; +//! transferSize = 4 * KKilo +//! iFlags = KDmaMemAddr; +//! +//! 2. Setup expected result. +//! 3. Create single transfer test and run test +//! +//! @SYMTestExpectedResults +//! +//! 1. TransfeArgs set up in DMA framework +//! 2. Expected results set up in DMA framework +//! 3. Fragment passes and KErrNone returned +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace TestOldStyleFragment_2 + { + const TInt srcAddr = 4 * KKilo; + const TInt desAddr = 4 * KKilo; + const TInt transferSize = 4 * KKilo; + + TDmaTransferArgs transferArgs(srcAddr,desAddr, transferSize, KDmaMemAddr); + const TRequestResults requestResult(KErrNone, 4); + const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); + + CSingleTransferTest testscenario_2 = CSingleTransferTest(_L("TestOldStyleFragment - Test Scenario 2"), 1, transferArgs, expectedResults,KKilo) + .UseNewDmaApi(EFalse); + + TTestCase testCase(&testscenario_2, EFalse, capAboveV1); + TTestCase testCaseConcurrent(&testscenario_2, ETrue, capAboveV1); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2561 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc TestOldstyleFragment using CSingleTransferTest +//! Test Scenario 3 - TransferSize=0 +//! +//! 1. Set up the arguments for aTransfeArgs using the settings below. +//! +//! SrcAddr = 32K +//! desAddr = 64K; +//! transferSize = 0 +//! iFlags = KDmaMemAddr; +//! +//! 2. Setup expected result. +//! 3. Create single transfer test and run test +//! +//! @SYMTestExpectedResults +//! +//! 1. TransfeArgs set up in DMA framework +//! 2. Expected results set up in DMA framework +//! 3. Fragment request Fails and KErrArgument returned +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace TestOldStyleFragment_3 + { + + const TInt srcAddr = 32 * KKilo; + const TInt desAddr = 64 * KKilo; + const TInt transferSize = 0; + + TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize,KDmaMemAddr); + const TRequestResults requestResult(KErrArgument, 0); + const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); + + CSingleTransferTest testscenario_3 = CSingleTransferTest(_L("TestOldStyleFragment - Test Scenario 3"), 1, transferArgs, expectedResults). + UseNewDmaApi(EFalse); + + TTestCase testCase(&testscenario_3, EFalse, capAboveV1); + TTestCase testCaseConcurrent(&testscenario_3, ETrue, capAboveV1); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2561 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc TestOldstyleFragment using CSingleTransferTest +//! Test Scenario 4 - TransferSize=1Byte +//! +//! 1. Set up the arguments for aTransfeArgs using the settings below. +//! +//! +//! SrcAddr = 32K; +//! desAddr = 64K; +//! transferSize = 1 byte +//! iFlags = KDmaMemAddr; +//! +//! 2. Setup expected result. +//! 3. Create single transfer test and run test +//! +//! @SYMTestExpectedResults +//! +//! 1. TransfeArgs set up in DMA framework +//! 2. Expected results set up in DMA framework +//! 3. Fragment request completes and KErrNone returned +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//------------------------------------------------------------------------------------------------ +namespace TestOldStyleFragment_4 + { + const TInt srcAddr = 32 * KKilo; + const TInt desAddr = 64 * KKilo; + const TInt transferSize = 1; + + TDmaTransferArgs transferArgs( srcAddr, desAddr, transferSize, KDmaMemAddr); + const TRequestResults requestResult(KErrNone, 1); + const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); + + CSingleTransferTest testscenario_4 = CSingleTransferTest(_L("TestOldStyleFragment - Test Scenario 4"), 1, transferArgs, expectedResults). + UseNewDmaApi(EFalse); + + TTestCase testCase(&testscenario_4, EFalse, capAboveV1); + TTestCase testCaseConcurrent(&testscenario_4, ETrue, capAboveV1); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2561 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc TestOldstyleFragment using CSingleTransferTest +//! Test Scenario 5 - TransferSize=1MB +//! +//! 1. Set up the arguments for aTransfeArgs using the settings below. +//! +//! SrcAddr = 16K; +//! desAddr = 2MB; +//! transferSize = 1MB +//! iFlags = KDmaMemAddr; +//! +//! 2. Setup expected result. +//! 3. Create single transfer test and run test +//! +//! @SYMTestExpectedResults +//! +//! 1. TransfeArgs set up in DMA framework +//! 2. Expected results set up in DMA framework +//! 3. Fragment request completes and KErrNone returned +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace TestOldStyleFragment_5 + { + const TInt srcAddr = 16 * KKilo; + const TInt desAddr = 2 * KMega; + const TInt transferSize = 1 * KMega; + + TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize, KDmaMemAddr); + + const TRequestResults requestResult(KErrNone); + const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); + + CSingleTransferTest testscenario_5 = CSingleTransferTest(_L("TestOldStyleFragment - Test Scenario 5"), 1, transferArgs, expectedResults). + UseNewDmaApi(EFalse); + + TTestCase testCase(&testscenario_5, EFalse, capAboveV1); + TTestCase testCaseConcurrent(&testscenario_5, ETrue, capAboveV1); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2561 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc TestOldstyleFragment using CSingleTransferTest +//! Test Scenario 6 - TransferSize=3MB +//! +//! 1. Set up the arguments for aTransfeArgs using the settings below. +//! +//! SrcAddr = 16K +//! desAddr = 4MB; +//! transferSize = 3MB +//! iFlags = KDmaMemAddr; +//! +//! 2. Setup expected result. +//! 3. Create single transfer test and run test +//! +//! @SYMTestExpectedResults +//! +//! 1. TransfeArgs set up in DMA framework +//! 2. Expected results set up in DMA framework +//! 3. Fragment request completes and KErrNone returned +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace TestOldStyleFragment_6 + { + const TInt srcAddr = 16 * KKilo; + const TInt desAddr = 4 * KMega; + const TInt transferSize = 3 * KMega; + TDmaTransferArgs transferArgs(srcAddr, desAddr, transferSize, KDmaMemAddr); + + const TRequestResults requestResult(KErrNone); + const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); + + CSingleTransferTest testscenario_6 = CSingleTransferTest(_L("TestOldStyleFragment - Test Scenario 6"), 1, transferArgs, expectedResults). + UseNewDmaApi(EFalse); + + TTestCase testCase(&testscenario_6, EFalse, capAboveV1); + TTestCase testCaseConcurrent(&testscenario_6, ETrue, capAboveV1); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2562 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc TestOldStyleDDmaRequest using CSingleTransferTest +//! Test Scenario 1 - aMaxTransferSize=0 +//! +//! 1. Set up the DDmaRequest using aMaxTransferSize set to 0. +//! 2. Setup expected result. +//! 3. Create single transfer test and run test +//! +//! @SYMTestExpectedResults +//! +//! 1. TransfeArgs set up in DMA framework +//! 2. Expected results set up in DMA framework +//! 3. DDmaRequest constructor behaves as expected and KErrArgument returned +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//------------------------------------------------------------------------------------------------ +namespace TestOldStyleDDmaRequest_1 + { + const TInt desAddr = 4 * KKilo; + const TInt transferSize = 4 * KKilo; + TDmaTransferArgs transferArgs(0, desAddr, transferSize, KDmaMemAddr); + + const TRequestResults requestResult(KErrNone, 0); + const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); + + CSingleTransferTest testscenario_1 = CSingleTransferTest(_L("TestOldStyleDDmaRequest - Test Scenario 1"), 1, transferArgs, expectedResults,0). + UseNewDmaApi(EFalse); + + TTestCase testCase(&testscenario_1, EFalse, capAboveV1); + TTestCase testCaseConcurrent(&testscenario_1, ETrue, capAboveV1); + } + +//!------------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2562 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc TestOldStyleDDmaRequest using CSingleTransferTest +//! Test Scenario 2 - aMaxTransferSize= 65535 +//! +//! 1. Set up the arguments for DDmaRequest using aMaxTransferSize set to 65535. +//! 2. Setup expected result. +//! 3. Create single transfer test and run test +//! +//! @SYMTestExpectedResults +//! +//! 1. TransfeArgs set up in DMA framework +//! 2. Expected results set up in DMA framework +//! 3. DDmaRequest constructor behaves as expected and KErrArgument returned +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//--------------------------------------------------------------------------------------------------- +namespace TestOldStyleDDmaRequest_2 + { + const TInt desAddr = 4 * KKilo; + const TInt transferSize = 4 * KKilo; + TDmaTransferArgs transferArgs(0, desAddr, transferSize, KDmaMemAddr); + + const TRequestResults requestResult(KErrNone, 1); + const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); + + CSingleTransferTest testscenario_2 = CSingleTransferTest(_L("TestOldStyleDDmaRequest - Test Scenario 2"), 1, transferArgs, expectedResults, 65535). + UseNewDmaApi(EFalse); + + TTestCase testCase(&testscenario_2, EFalse, capAboveV1); + TTestCase testCaseConcurrent(&testscenario_2, ETrue, capAboveV1); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2563 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc TestNewStyleDDmaRequest using CSingleTransferTest +//! Test Scenario 1 - aMaxTransferSize=0 +//! +//! 1. Set up the DDmaRequest using aMaxTransferSize set to 0. +//! 2. Setup expected result. +//! 3. Create single transfer test and run test +//! +//! @SYMTestExpectedResults +//! +//! 1. TransfeArgs set up in DMA framework +//! 2. Expected results set up in DMA framework +//! 3. DDmaRequest constructor behaves as expected and KErrArgument returned +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace TestNewStyleDDmaRequest_1 + { + const TInt desAddr = 4 * KKilo; + const TInt transferSize = 4 * KKilo; + TDmaTransferArgs transferArgs(0, desAddr, transferSize, KDmaMemAddr); + + const TRequestResults requestResult(KErrNone, 0); + const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); + + CSingleTransferTest testscenario_1(_L("TestNewStyleDDmaRequest - Test Scenario 1"), 1, transferArgs, expectedResults,0); + + TTestCase testCase(&testscenario_1, EFalse, capAboveV1); + TTestCase testCaseConcurrent(&testscenario_1, ETrue, capAboveV1); + } + +//!------------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-DMA-2563 +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc TestNewStyleDDmaRequest using CSingleTransferTest +//! Test Scenario 2 - aMaxTransferSize= 65535 +//! +//! 1. Set up the arguments for DDmaRequest using aMaxTransferSize set to 65535. +//! 2. Setup expected result. +//! 3. Create single transfer test and run test +//! +//! @SYMTestExpectedResults +//! +//! 1. TransfeArgs set up in DMA framework +//! 2. Expected results set up in DMA framework +//! 3. DDmaRequest constructor behaves as expected and KErrArgument returned +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//--------------------------------------------------------------------------------------------------- +namespace TestNewStyleDDmaRequest_2 + { + const TInt desAddr = 4 * KKilo; + const TInt transferSize = 4 * KKilo; + TDmaTransferArgs transferArgs(0, desAddr, transferSize, KDmaMemAddr); + + const TRequestResults requestResult(KErrNone, 1); + const TResultSet expectedResults(KErrNone, requestResult, KErrNone, threadCallback); + + CSingleTransferTest testscenario_2(_L("TestNewStyleDDmaRequest - Test Scenario 2"), 1, transferArgs, expectedResults, 65535); + + TTestCase testCase(&testscenario_2, EFalse, capAboveV1); + TTestCase testCaseConcurrent(&testscenario_2, ETrue, capAboveV1); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID PBASE-DMA-FUNC-xxx +//! @SYMTestType CIT +//! @SYMPREQ REQ +//! @SYMTestCaseDesc SmallFrags: This test provokes the failure seen in DEF140598 +//! The test checks that requests with small fragments +//! do not trigger a spurious missed interrupt clean up +//! +//! @SYMTestExpectedResults +//! +//! 1. +//! 2. +//! +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +namespace SmallFrags + { + const TInt size = 32; + TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr); + + const TResultSet expectedResults(threadCallback); + + TTestCase testCase( + new (ELeave) CSingleTransferTest(_L("8 * 4byte frags"), 10, transferArgs, expectedResults, 4), + EFalse, capAboveV1); + } + + +//TODO TTestCase could automatically be added to aray by ctor +// +//Append new test cases here +static TTestCase* StaticTestArray[] = { + &Simple_1::testCase, + &Simple_1::testCaseConcurrent, + &Simple_2::testCase, + &Simple_2::testCaseConcurrent, + &Callback::testCase, + &Callback::testCaseOldRequest, + &ISR_Reque::endOnRedo::testCase, + &ISR_Reque::endOnIsrCb::testCase, + &ISR_Reque::endOnThreadCb::testCase, + &ISR_Reque::changeSize::testCase, +#ifdef _DEBUG + &ISR_Reque::invalidAddresses::testCase, // addresses only checked in UDEB +#endif + //&ISR_Reque::multipleFragments::testCase, // This error condition is currently caught by a FAULT instead of a return code + &Multipart::testCase, + &IsrAndDfc::DfcBeforeIsr::testCase, + &IsrAndDfc::IsrBeforeDfc::testCase, + &_2D_Test::testCase2d, + &FragmentationCount::testCase, + &FragmentationCount::testCase2, + &SmallFrags::testCase, +#ifndef _DEBUG + // Benchmarks are only really meaningful + // on UREL builds + &Benchmark::Frag::testCase_256k, + &Benchmark::Frag::testCase_8k, + &Benchmark::Transfer::_128K::testCase_128, + &Benchmark::Transfer::_128K::testCase_16, + &Benchmark::Transfer::_128K::testCase_4, + &Benchmark::Transfer::_128K::testCase_1, + &Benchmark::Transfer::_4Bytes::testCase, + &Benchmark::Transfer::_4Mb::testCase, + &Benchmark::CompareIsrDfcCb::Dfc::_4Bytes::testCase, + &Benchmark::CompareIsrDfcCb::Isr::_4Bytes::testCase, + &Benchmark::CompareIsrDfcCb::Dfc::_4K::testCase, + &Benchmark::CompareIsrDfcCb::Isr::_4K::testCase, +#endif + &TestNewStyleFragment_1::testCase, + &TestNewStyleFragment_1::testCaseConcurrent, + &TestNewStyleFragment_2::testCase, + &TestNewStyleFragment_2::testCaseConcurrent, + //&TestNewStyleFragment_3::testCase, + //&TestNewStyleFragment_3::testCaseConcurrent, + &TestNewStyleFragment_4::testCase, + &TestNewStyleFragment_4::testCaseConcurrent, + &TestNewStyleFragment_5::testCase, + &TestNewStyleFragment_5::testCaseConcurrent, + &TestNewStyleFragment_6::testCase, + &TestNewStyleFragment_6::testCaseConcurrent, + &TestOldStyleFragment_1::testCase, + &TestOldStyleFragment_1::testCaseConcurrent, + &TestOldStyleFragment_2::testCase, + &TestOldStyleFragment_2::testCaseConcurrent, + //&TestOldStyleFragment_3::testCase, + //&TestOldStyleFragment_3::testCaseConcurrent, + &TestOldStyleFragment_4::testCase, + &TestOldStyleFragment_4::testCaseConcurrent, + &TestOldStyleFragment_5::testCase, + &TestOldStyleFragment_5::testCaseConcurrent, + &TestOldStyleFragment_6::testCase, + &TestOldStyleFragment_6::testCaseConcurrent, + &TestOldStyleDDmaRequest_1::testCase, + &TestOldStyleDDmaRequest_1::testCaseConcurrent, + &TestOldStyleDDmaRequest_2::testCase, + &TestOldStyleDDmaRequest_2::testCaseConcurrent, + &TestNewStyleDDmaRequest_1::testCase, + &TestNewStyleDDmaRequest_1::testCaseConcurrent, + &TestNewStyleDDmaRequest_2::testCase, + &TestNewStyleDDmaRequest_2::testCaseConcurrent, +}; + +RPointerArray TestArray(StaticTestArray, ARRAY_LENGTH(StaticTestArray));