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