kerneltest/e32test/dmav2/self_test.cpp
branchRCL_3
changeset 117 5b5d147c7838
parent 110 c734af59ce98
child 118 70db9e7362de
child 136 743008598095
child 147 bbf8bed59bcb
equal deleted inserted replaced
110:c734af59ce98 117:5b5d147c7838
     1 /*
       
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:
       
    15 * This file contains unit tests for the test framework itself.
       
    16 * They should be run if changes have been made to
       
    17 * to the user side test framework code ie. anything in the dmav2
       
    18 * directory other than the d_* driver code, or test_cases.cpp
       
    19 *
       
    20 */
       
    21 
       
    22 #include "d_dma2.h"
       
    23 #include "u32std.h"
       
    24 #include "t_dma2.h"
       
    25 #include "cap_reqs.h"
       
    26 
       
    27 #define __E32TEST_EXTENSION__
       
    28 #include <e32test.h>
       
    29 #include <e32debug.h>
       
    30 #include <e32svr.h>
       
    31 
       
    32 static RTest test(_L("t_dma2 test framework tests"));
       
    33 
       
    34 void RDmaSession::SelfTest()
       
    35 	{
       
    36 	test.Start(_L("Simple transfer test"));
       
    37 	test.Next(_L("Open session"));
       
    38 	RDmaSession session;
       
    39 	TInt r = session.Open();
       
    40 	test_KErrNone(r);
       
    41 
       
    42 	test.Next(_L("Get test info"));
       
    43 	TDmaV2TestInfo testInfo;
       
    44 	r = session.GetTestInfo(testInfo);
       
    45 	test_KErrNone(r);
       
    46 
       
    47 	if(gVerboseOutput)
       
    48 	{
       
    49 	Print(testInfo);
       
    50 	}
       
    51 
       
    52 	test.Next(_L("Channel open"));
       
    53 	TUint channelCookie=0;
       
    54 	r = session.ChannelOpen(16, channelCookie);
       
    55 	test.Printf(_L("cookie recived = 0x%08x\n"), channelCookie);
       
    56 	test_KErrNone(r);
       
    57 
       
    58 	test.Next(_L("Get Channel caps"));
       
    59 	SDmacCaps channelCaps;
       
    60 	r = session.ChannelCaps(channelCookie, channelCaps);
       
    61 	test_KErrNone(r);
       
    62 	if(gVerboseOutput)
       
    63 	{
       
    64 	PRINT(channelCaps.iChannelPriorities);
       
    65 	PRINT(channelCaps.iChannelPauseAndResume);
       
    66 	PRINT(channelCaps.iAddrAlignedToElementSize);
       
    67 	PRINT(channelCaps.i1DIndexAddressing);
       
    68 	PRINT(channelCaps.i2DIndexAddressing);
       
    69 	PRINT(channelCaps.iSynchronizationTypes);
       
    70 	PRINT(channelCaps.iBurstTransactions);
       
    71 	PRINT(channelCaps.iDescriptorInterrupt);
       
    72 	PRINT(channelCaps.iFrameInterrupt);
       
    73 	PRINT(channelCaps.iLinkedListPausedInterrupt);
       
    74 	PRINT(channelCaps.iEndiannessConversion);
       
    75 	PRINT(channelCaps.iGraphicsOps);
       
    76 	PRINT(channelCaps.iRepeatingTransfers);
       
    77 	PRINT(channelCaps.iChannelLinking);
       
    78 	PRINT(channelCaps.iHwDescriptors);
       
    79 	PRINT(channelCaps.iSrcDstAsymmetry);
       
    80 	PRINT(channelCaps.iAsymHwDescriptors);
       
    81 	PRINT(channelCaps.iBalancedAsymSegments);
       
    82 	PRINT(channelCaps.iAsymCompletionInterrupt);
       
    83 	PRINT(channelCaps.iAsymDescriptorInterrupt);
       
    84 	PRINT(channelCaps.iAsymFrameInterrupt);
       
    85 	PRINT(channelCaps.iReserved[0]);
       
    86 	PRINT(channelCaps.iReserved[1]);
       
    87 	PRINT(channelCaps.iReserved[2]);
       
    88 	PRINT(channelCaps.iReserved[3]);
       
    89 	PRINT(channelCaps.iReserved[4]);	
       
    90 	}
       
    91 
       
    92 	test.Next(_L("Get extended Channel caps (TDmacTestCaps)"));
       
    93 	TDmacTestCaps extChannelCaps;
       
    94 	r = session.ChannelCaps(channelCookie, extChannelCaps);
       
    95 	test_KErrNone(r);
       
    96 	test.Printf(_L("PIL version = %d\n"), extChannelCaps.iPILVersion);
       
    97 
       
    98 	const TBool newPil = (extChannelCaps.iPILVersion > 1);
       
    99 
       
   100 	test.Next(_L("Create Dma request - max fragment size 32K"));
       
   101 	TUint reqCookie=0;
       
   102 	r = session.RequestCreate(channelCookie, reqCookie, 32 * KKilo);
       
   103 	test.Printf(_L("cookie recived = 0x%08x\n"), reqCookie);
       
   104 	test_KErrNone(r);
       
   105 
       
   106 	if(newPil)
       
   107 		{
       
   108 		test.Next(_L("Create Dma request (with new-style callback)"));
       
   109 		TUint reqCookieNewStyle=0;
       
   110 		r = session.RequestCreateNew(channelCookie, reqCookieNewStyle);
       
   111 		test.Printf(_L("cookie recived = 0x%08x\n"), reqCookieNewStyle );
       
   112 		test_KErrNone(r);
       
   113 
       
   114 		test.Next(_L("Fragment for ISR callback"));
       
   115 		const TInt size = 128 * KKilo;
       
   116 		TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr);
       
   117 		r = session.FragmentRequest(reqCookieNewStyle, transferArgs);
       
   118 		test_KErrNone(r);
       
   119 
       
   120 		TIsrRequeArgs reque;
       
   121 		test.Next(_L("Queue ISR callback - with default re-queue"));
       
   122 		r = session.QueueRequestWithRequeue(reqCookieNewStyle, &reque, 1);
       
   123 		test_KErrNone(r);
       
   124 
       
   125 		test.Next(_L("Destroy new-style Dma request"));
       
   126 		r = session.RequestDestroy(reqCookieNewStyle);
       
   127 		test_KErrNone(r);
       
   128 
       
   129 		test.Next(_L("Attempt to destroy request again "));
       
   130 		r = session.RequestDestroy(reqCookieNewStyle);
       
   131 		test_Equal(KErrNotFound, r);
       
   132 		}
       
   133 
       
   134 	test.Next(_L("Open chunk handle"));
       
   135 	RChunk chunk;
       
   136 	r = session.OpenSharedChunk(chunk);
       
   137 	test_KErrNone(r);
       
   138 	if(gVerboseOutput)
       
   139 	{
       
   140 	test.Printf(_L("chunk base = 0x%08x\n"), chunk.Base());
       
   141 	test.Printf(_L("chunk size = %d\n"), chunk.Size());
       
   142 	}
       
   143 	test(chunk.IsWritable());
       
   144 	test(chunk.IsReadable());
       
   145 
       
   146 	test.Next(_L("Fragment(old style)"));
       
   147 	const TInt size = 128 * KKilo;
       
   148 	TInt i;
       
   149 	for(i = 0; i<10; i++)
       
   150 		{
       
   151 		TUint64 time = 0;
       
   152 		TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr);
       
   153 		r = session.FragmentRequestOld(reqCookie, transferArgs, &time);
       
   154 		test_KErrNone(r);
       
   155 		if(gVerboseOutput)
       
   156 			{
       
   157 			test.Printf(_L("%lu us\n"), time);
       
   158 			}
       
   159 	}
       
   160 
       
   161 	test.Next(_L("Queue"));
       
   162 	TRequestStatus status;
       
   163 
       
   164 	for(i = 0; i<10; i++)
       
   165 		{
       
   166 		TUint64 time = 0;
       
   167 		r = session.QueueRequest(reqCookie, status, 0, &time);
       
   168 		User::WaitForRequest(status);
       
   169 		test_KErrNone(r);
       
   170 		if(gVerboseOutput)
       
   171 			{
       
   172 			test.Printf(_L("%lu us\n"), time);
       
   173 			}
       
   174 		}
       
   175 
       
   176 	if(newPil)
       
   177 		{
       
   178 		test.Next(_L("Fragment(new style)"));
       
   179 		TDmaTransferArgs transferArgs;
       
   180 		transferArgs.iSrcConfig.iAddr = 0;
       
   181 		transferArgs.iDstConfig.iAddr = size;
       
   182 		transferArgs.iSrcConfig.iFlags = KDmaMemAddr;
       
   183 		transferArgs.iDstConfig.iFlags = KDmaMemAddr;
       
   184 		transferArgs.iTransferCount = size;
       
   185 
       
   186 		for(i = 0; i<10; i++)
       
   187 			{
       
   188 			TUint64 time = 0;
       
   189 			r = session.FragmentRequest(reqCookie, transferArgs, &time);
       
   190 			test_KErrNone(r);
       
   191 			if(gVerboseOutput)
       
   192 				{
       
   193 				test.Printf(_L("%lu us\n"), time);
       
   194 				}
       
   195 			}
       
   196 		}
       
   197 
       
   198 	test.Next(_L("Queue"));
       
   199 	TCallbackRecord record;
       
   200 	r = session.QueueRequest(reqCookie, &record);
       
   201 	test_KErrNone(r);
       
   202 
       
   203 	test.Next(_L("check TCallbackRecord record"));
       
   204 	if(gVerboseOutput)
       
   205 	{
       
   206 	record.Print();
       
   207 	}
       
   208 	const TCallbackRecord expected(TCallbackRecord::EThread, 1);
       
   209 	if(!(record == expected))
       
   210 		{
       
   211 		test.Printf(_L("TCallbackRecords did not match"));
       
   212 		if(gVerboseOutput)
       
   213 			{
       
   214 			test.Printf(_L("expected:"));
       
   215 			expected.Print();
       
   216 			}
       
   217 		TEST_FAULT;
       
   218 		}
       
   219 
       
   220 	test.Next(_L("Destroy Dma request"));
       
   221 	r = session.RequestDestroy(reqCookie);
       
   222 	test_KErrNone(r);
       
   223 
       
   224 	test.Next(_L("Close chunk handle"));
       
   225 	chunk.Close();
       
   226 
       
   227 	test.Next(_L("Channel close"));
       
   228 	r = session.ChannelClose(channelCookie);
       
   229 	test_KErrNone(r);
       
   230 
       
   231 	test.Next(_L("Channel close (same again)"));
       
   232 	r = session.ChannelClose(channelCookie);
       
   233 	test_Equal(KErrNotFound, r);
       
   234 
       
   235 	test.Next(_L("Close session"));
       
   236 	RTest::CloseHandleAndWaitForDestruction(session);
       
   237 
       
   238 	test.End();
       
   239 
       
   240 	}
       
   241 
       
   242 const SDmacCaps KTestCapSet =
       
   243 	{6,										// TInt iChannelPriorities;
       
   244 	 EFalse,								// TBool iChannelPauseAndResume;
       
   245 	 ETrue,									// TBool iAddrAlignedToElementSize;
       
   246 	 EFalse,								// TBool i1DIndexAddressing;
       
   247 	 EFalse,								// TBool i2DIndexAddressing;
       
   248 	 KDmaSyncSizeElement | KDmaSyncSizeFrame |
       
   249 	 KDmaSyncSizeBlock,					   // TUint iSynchronizationTypes;
       
   250 	 KDmaBurstSize4 | KDmaBurstSize8,	   // TUint iBurstTransactions;
       
   251 	 EFalse,							   // TBool iDescriptorInterrupt;
       
   252 	 EFalse,							   // TBool iFrameInterrupt;
       
   253 	 EFalse,							   // TBool iLinkedListPausedInterrupt;
       
   254 	 EFalse,							   // TBool iEndiannessConversion;
       
   255 	 0,									   // TUint iGraphicsOps;
       
   256 	 ETrue,								   // TBool iRepeatingTransfers;
       
   257 	 EFalse,							   // TBool iChannelLinking;
       
   258 	 ETrue,								   // TBool iHwDescriptors;
       
   259 	 EFalse,							   // TBool iSrcDstAsymmetry;
       
   260 	 EFalse,							   // TBool iAsymHwDescriptors;
       
   261 	 EFalse,							   // TBool iBalancedAsymSegments;
       
   262 	 EFalse,							   // TBool iAsymCompletionInterrupt;
       
   263 	 EFalse,							   // TBool iAsymDescriptorInterrupt;
       
   264 	 EFalse,							   // TBool iAsymFrameInterrupt;
       
   265 	 {0, 0, 0, 0, 0}					   // TUint32 iReserved[5];
       
   266 	};
       
   267 
       
   268 const TDmacTestCaps KDmacTestCapsV1(KTestCapSet, 1);
       
   269 const TDmacTestCaps KDmacTestCapsV2(KTestCapSet, 2);
       
   270 
       
   271 void TDmaCapability::SelfTest()
       
   272 	{
       
   273 	test.Start(_L("Unit test_Value of TDmaCapability::CompareToDmaCaps\n"));
       
   274 
       
   275 	{
       
   276 	test.Next(_L("ENone\n"));
       
   277 	TResult t = none.CompareToDmaCaps(KTestCapSet);
       
   278 	test_Value(t, t == ERun);
       
   279 	}
       
   280 
       
   281 	{
       
   282 	test.Next(_L("EChannelPauseAndResume - wanted\n"));
       
   283 	TResult t = pauseRequired.CompareToDmaCaps(KTestCapSet);
       
   284 	test_Value(t, t == EFail);
       
   285 	}
       
   286 	{
       
   287 	test.Next(_L("EChannelPauseAndResume - wanted - Allow skip\n"));
       
   288 	TResult t = pauseRequired_skip.CompareToDmaCaps(KTestCapSet);
       
   289 	test_Value(t, t == ESkip);
       
   290 	}
       
   291 	{
       
   292 	test.Next(_L("EChannelPauseAndResume - not wanted\n"));
       
   293 	TResult t = pauseNotWanted.CompareToDmaCaps(KTestCapSet);
       
   294 	test_Value(t, t == ERun);
       
   295 	}
       
   296 
       
   297 	{
       
   298 	test.Next(_L("EHwDescriptors - not wanted\n"));
       
   299 	TResult t = hwDesNotWanted.CompareToDmaCaps(KTestCapSet);
       
   300 	test_Value(t, t == EFail);
       
   301 	}
       
   302 
       
   303 	{
       
   304 	test.Next(_L("EHwDescriptors - not wanted - Allow skip\n"));
       
   305 	TResult t = hwDesNotWanted_skip.CompareToDmaCaps(KTestCapSet);
       
   306 	test_Value(t, t == ESkip);
       
   307 	}
       
   308 
       
   309 	{
       
   310 	test.Next(_L("EHwDescriptors - wanted\n"));
       
   311 	TResult t = hwDesWanted.CompareToDmaCaps(KTestCapSet);
       
   312 	test_Value(t, t == ERun);
       
   313 	}
       
   314 
       
   315 
       
   316 //TODO use this macro for the above tests
       
   317 
       
   318 // Note: The construction of the test description message
       
   319 // is horribly confusing. The _L macro will make the
       
   320 // *first* string token wide, but not the next two.
       
   321 // Therefore these must be made wide or compilier
       
   322 // will complain about concatination of narrow and wide string
       
   323 // literals
       
   324 #define CAP_TEST(CAP, CAPSET, EXPCT)\
       
   325 	{\
       
   326 	test.Next(_L(#CAP L" against " L ## #CAPSET));\
       
   327 	TResult t = (CAP).CompareToDmaCaps(CAPSET);\
       
   328 	test_Equal(EXPCT, t);\
       
   329 	}
       
   330 
       
   331 
       
   332 	CAP_TEST(capEqualV1, KDmacTestCapsV1, ERun);
       
   333 	CAP_TEST(capEqualV2, KDmacTestCapsV2, ERun);
       
   334 	CAP_TEST(capEqualV1, KDmacTestCapsV2, ESkip);
       
   335 	CAP_TEST(capEqualV2, KDmacTestCapsV1, ESkip);
       
   336 	CAP_TEST(capEqualV2Fatal, KDmacTestCapsV1, EFail);
       
   337 
       
   338 	CAP_TEST(capAboveV1, KDmacTestCapsV2, ERun);
       
   339 	CAP_TEST(capBelowV2, KDmacTestCapsV1, ERun);
       
   340 	CAP_TEST(capAboveV1, KDmacTestCapsV1, ESkip);
       
   341 	CAP_TEST(capBelowV2, KDmacTestCapsV2, ESkip);
       
   342 
       
   343 	test.End();
       
   344 	}
       
   345 
       
   346 void TTestCase::SelfTest()
       
   347 	{
       
   348 	//TODO should use macros for these tests
       
   349 	test.Start(_L("Unit test of TTestCase::TestCaseValid\n"));
       
   350 
       
   351 	TTestCase testCase(NULL, EFalse, pauseRequired, hwDesNotWanted);
       
   352 	test.Next(_L("pauseRequired, hwDesNotWanted\n"));
       
   353 	TResult t = testCase.TestCaseValid(KTestCapSet);
       
   354 	test_Value(t, t == EFail);
       
   355 
       
   356 	test.Next(_L("pauseRequired_skip, hwDesNotWanted\n"));
       
   357 	testCase.iChannelCaps[0] = pauseRequired_skip;
       
   358 	t = testCase.TestCaseValid(KTestCapSet);
       
   359 	test_Value(t, t == EFail);
       
   360 
       
   361 	test.Next(_L("pauseRequired_skip, hwDesNotWanted_skip\n"));
       
   362 	testCase.iChannelCaps[1] = hwDesNotWanted_skip;
       
   363 	t = testCase.TestCaseValid(KTestCapSet);
       
   364 	test_Value(t, t == ESkip);
       
   365 
       
   366 	test.Next(_L("pauseNotWanted, hwDesNotWanted_skip\n"));
       
   367 	testCase.iChannelCaps[0] = pauseNotWanted;
       
   368 	t = testCase.TestCaseValid(KTestCapSet);
       
   369 	test_Value(t, t == ESkip);
       
   370 
       
   371 	test.Next(_L("pauseNotWanted, hwDesWanted\n"));
       
   372 	testCase.iChannelCaps[1] = hwDesWanted;
       
   373 	t = testCase.TestCaseValid(KTestCapSet);
       
   374 	test_Value(t, t == ERun);
       
   375 
       
   376 	test.Next(_L("pauseNotWanted\n"));
       
   377 	testCase.iChannelCaps[1] = none;
       
   378 	t = testCase.TestCaseValid(KTestCapSet);
       
   379 	test_Value(t, t == ERun);
       
   380 
       
   381 	test.Next(_L("pauseNotWanted + V1 PIL required\n"));
       
   382 	testCase.iChannelCaps[1] = capAboveV1;
       
   383 	test.Next(_L("Against KDmacTestCapsV1"));
       
   384 	t = testCase.TestCaseValid(KDmacTestCapsV1);
       
   385 	test_Equal(ESkip, t);
       
   386 	test.Next(_L("Against KDmacTestCapsV2"));
       
   387 	t = testCase.TestCaseValid(KDmacTestCapsV2);
       
   388 	test_Equal(ERun, t);
       
   389 
       
   390 	test.Next(_L("pauseNotWanted + >V1 PIL required\n"));
       
   391 	testCase.iChannelCaps[1] = capBelowV2;
       
   392 	test.Next(_L("Against KDmacTestCapsV1"));
       
   393 	t = testCase.TestCaseValid(KDmacTestCapsV1);
       
   394 	test_Equal(ERun, t);
       
   395 	test.Next(_L("Against KDmacTestCapsV2"));
       
   396 	t = testCase.TestCaseValid(KDmacTestCapsV2);
       
   397 	test_Equal(ESkip, t);
       
   398 
       
   399 	test.End();
       
   400 	test.Close();
       
   401 	}
       
   402 
       
   403 
       
   404 void TTransferIter::SelfTest()
       
   405 	{
       
   406 	test.Start(_L("No skip"));
       
   407 
       
   408 	const TUint8 src[9] = {
       
   409 			1 ,2, 3,
       
   410 			4, 5, 6,
       
   411 			7, 8, 9
       
   412 	};
       
   413 
       
   414 	const TUint32 addr = (TUint32)src;
       
   415 	const TUint elementSize = 1;
       
   416 	const TUint elementSkip = 0;
       
   417 	const TUint elementsPerFrame = 3;
       
   418 	const TUint frameSkip = 0;
       
   419 	const TUint framesPerTransfer = 3;
       
   420 	TDmaTransferConfig cfg(addr, elementSize, elementsPerFrame, framesPerTransfer,
       
   421 			elementSkip, frameSkip, KDmaMemAddr
       
   422 			);
       
   423 
       
   424 	TTransferIter iter(cfg, 0);
       
   425 	TTransferIter end;
       
   426 	TInt i;
       
   427 	for(i = 0; i<9; i++, ++iter)
       
   428 		{
       
   429 		test_Equal(src[i],*iter);
       
   430 		};
       
   431 
       
   432 
       
   433 	test.Next(_L("90 degree rotation"));
       
   434 	// Now imagine that we wanted to perform a rotation
       
   435 	// as we write, so that we wrote out the following
       
   436 
       
   437 	const TUint8 expected[9] = {
       
   438 		7, 4, 1,
       
   439 		8, 5, 2,
       
   440 		9, 6, 3
       
   441 	};
       
   442 
       
   443 	TUint8 dst[9] = {0};
       
   444 	TDmaTransferConfig dst_cfg(cfg);
       
   445 	dst_cfg.iAddr = (TUint32)&dst[2];
       
   446 	dst_cfg.iElementSkip = 2;
       
   447 	dst_cfg.iFrameSkip = -8;
       
   448 
       
   449 	TTransferIter dst_iter(dst_cfg, 0);
       
   450 	for(i=0; dst_iter != end; i++, ++dst_iter)
       
   451 		{
       
   452 		TEST_ASSERT(i<9);
       
   453 		*dst_iter=src[i];
       
   454 		};
       
   455 
       
   456 	for(i=0; i<9; i++)
       
   457 		{
       
   458 		test_Equal(expected[i],dst[i]);
       
   459 		}
       
   460 	}
       
   461 
       
   462 void TCallbackRecord::SelfTest()
       
   463 	{
       
   464 	test.Start(_L("SeltTest of TCallbackRecord"));
       
   465 
       
   466 	test.Next(_L("create default TCallbackRecord record, record2"));
       
   467 	TCallbackRecord record;
       
   468 	const TCallbackRecord record2;
       
   469 	if(gVerboseOutput)
       
   470 	{
       
   471 	test.Next(_L("Print record"));
       
   472 	record.Print();
       
   473 	}
       
   474 
       
   475 	test.Next(_L("test (record == record2)"));
       
   476 	if(!(record == record2))
       
   477 		{
       
   478 		if(gVerboseOutput)
       
   479 			{
       
   480 			record2.Print();
       
   481 			}
       
   482 		TEST_FAULT;
       
   483 		}
       
   484 
       
   485 	//A series of callback masks
       
   486 	//Note these combinations do not necessarily represent
       
   487 	//possible callback combinations
       
   488 	TUint callbacks[]  =
       
   489 		{
       
   490 		EDmaCallbackDescriptorCompletion,
       
   491 		EDmaCallbackDescriptorCompletion,
       
   492 		EDmaCallbackDescriptorCompletion,
       
   493 		EDmaCallbackDescriptorCompletion,
       
   494 		EDmaCallbackFrameCompletion_Src,
       
   495 		EDmaCallbackFrameCompletion_Dst,
       
   496 		EDmaCallbackDescriptorCompletion_Src | EDmaCallbackDescriptorCompletion_Dst,
       
   497 		EDmaCallbackDescriptorCompletion_Src | EDmaCallbackFrameCompletion_Src | EDmaCallbackLinkedListPaused_Dst,
       
   498 		EDmaCallbackRequestCompletion | EDmaCallbackRequestCompletion_Src,
       
   499 		EDmaCallbackDescriptorCompletion_Dst
       
   500 		};
       
   501 	test.Next(_L("Feed a series of callback masks in to record"));
       
   502 	const TInt length = ARRAY_LENGTH(callbacks);
       
   503 	for(TInt i = 0; i < length; i++)
       
   504 		{
       
   505 		record.ProcessCallback(callbacks[i], EDmaResultOK);
       
   506 		}
       
   507 	
       
   508 	if(gVerboseOutput)
       
   509 	{
       
   510 	test.Next(_L("Print record"));
       
   511 	record.Print();
       
   512 	}
       
   513 
       
   514 	test.Next(_L("test GetCount"));
       
   515 	test_Equal(1, record.GetCount(EDmaCallbackRequestCompletion));
       
   516 	test_Equal(1, record.GetCount(EDmaCallbackRequestCompletion_Src));
       
   517 	test_Equal(0, record.GetCount(EDmaCallbackRequestCompletion_Dst));
       
   518 	test_Equal(4, record.GetCount(EDmaCallbackDescriptorCompletion));
       
   519 	test_Equal(2, record.GetCount(EDmaCallbackDescriptorCompletion_Src));
       
   520 	test_Equal(2, record.GetCount(EDmaCallbackDescriptorCompletion_Dst));
       
   521 	test_Equal(0, record.GetCount(EDmaCallbackFrameCompletion));
       
   522 	test_Equal(2, record.GetCount(EDmaCallbackFrameCompletion_Src));
       
   523 	test_Equal(1, record.GetCount(EDmaCallbackFrameCompletion_Dst));
       
   524 	test_Equal(0, record.GetCount(EDmaCallbackLinkedListPaused));
       
   525 	test_Equal(0, record.GetCount(EDmaCallbackLinkedListPaused_Src));
       
   526 	test_Equal(1, record.GetCount(EDmaCallbackLinkedListPaused_Dst));
       
   527 
       
   528 	test.Next(_L("test expected == record"));
       
   529 	const TCallbackRecord expected(TCallbackRecord::EThread, 1, 1, 0, 4, 2, 2, 0, 2, 1, 0, 0, 1);
       
   530 	if(!(expected == record))
       
   531 		{
       
   532 		if(gVerboseOutput)
       
   533 			{
       
   534 			expected.Print();
       
   535 			}
       
   536 		TEST_FAULT;
       
   537 		}
       
   538 
       
   539 	test.Next(_L("modify record: test expected != record"));
       
   540 	record.SetCount(EDmaCallbackFrameCompletion, 10);
       
   541 	if(expected == record)
       
   542 		{
       
   543 		if(gVerboseOutput)
       
   544 			{
       
   545 			expected.Print();
       
   546 			}
       
   547 		TEST_FAULT;
       
   548 		}
       
   549 
       
   550 	test.Next(_L("test Reset()"));
       
   551 	record.Reset();
       
   552 	test(record == record2);
       
   553 
       
   554 	test.End();
       
   555 	}
       
   556 
       
   557 void CDmaBenchmark::SelfTest()
       
   558 	{
       
   559 	test.Start(_L("SelfTest of CDmaBenchmark"));
       
   560 	test.Next(_L("MeanResult()"));
       
   561 
       
   562 	TUint64 results[] = {8, 12, 1, 19, 3, 17, 10};
       
   563 	const TInt count = ARRAY_LENGTH(results);
       
   564 
       
   565 	CDmaBmFragmentation fragTest(_L("SelfTest"), count, TDmaTransferArgs(), 0);
       
   566 
       
   567 	for(TInt i = 0; i < count; i++)
       
   568 		{
       
   569 		fragTest.iResultArray.Append(results[i]);
       
   570 		}
       
   571 	test_Equal(10, fragTest.MeanResult());
       
   572 
       
   573 	test.End();
       
   574 	}
       
   575 
       
   576 void TAddrRange::SelfTest()
       
   577 	{
       
   578 	test.Start(_L("SelfTest of TAddrRange"));
       
   579 	TAddrRange a(0, 8);
       
   580 	TAddrRange b(8, 8);
       
   581 
       
   582 	test_Equal(7, a.End());
       
   583 	test_Equal(15, b.End());
       
   584 
       
   585 	test(!a.Overlaps(b));
       
   586 	test(!b.Overlaps(a));
       
   587 	test(a.Overlaps(a));
       
   588 	test(b.Overlaps(b));
       
   589 
       
   590 	TAddrRange c(7, 2);
       
   591 	test_Equal(8, c.End());
       
   592 
       
   593 	test(a.Overlaps(c));
       
   594 	test(c.Overlaps(a));
       
   595 	test(b.Overlaps(c));
       
   596 	test(c.Overlaps(b));
       
   597 
       
   598 	TAddrRange d(0, 24);
       
   599 	test(a.Overlaps(d));
       
   600 	test(d.Overlaps(a));
       
   601 
       
   602 	test(b.Overlaps(d));
       
   603 	test(d.Overlaps(b));
       
   604 
       
   605 	test(d.Contains(d));
       
   606 
       
   607 	test(d.Contains(a));
       
   608 	test(!a.Contains(d));
       
   609 
       
   610 	test(d.Contains(b));
       
   611 	test(!b.Contains(d));
       
   612 
       
   613 	test(!a.Contains(b));
       
   614 	test(!b.Contains(a));
       
   615 	test.End();
       
   616 	}
       
   617 
       
   618 void TAddressParms::SelfTest()
       
   619 	{
       
   620 	test.Start(_L("SelfTest of TAddressParms"));
       
   621 	const TAddressParms pA(0, 32, 8);
       
   622 	test(pA == pA);
       
   623 	test(pA.Overlaps(pA));
       
   624 
       
   625 	const TAddrRange rA(4, 8);
       
   626 	const TAddrRange rB(16, 8);
       
   627 	const TAddrRange rC(28, 8);
       
   628 	const TAddrRange rD(4, 32);
       
   629 
       
   630 	test(pA.Overlaps(rA));
       
   631 	test(!pA.Overlaps(rB));
       
   632 	test(pA.Overlaps(rC));
       
   633 	test(pA.Overlaps(rD));
       
   634 
       
   635 	const TAddressParms pB(8, 16, 8);
       
   636 	test(!(pA == pB));
       
   637 	test(!(pB == pA));
       
   638 	test(!pA.Overlaps(pB));
       
   639 	test(!pB.Overlaps(pA));
       
   640 
       
   641 	const TAddressParms pC(8, 28, 8);
       
   642 	test(pC.Overlaps(pA));
       
   643 	test(pC.Overlaps(pB));
       
   644 
       
   645 	const TAddressParms pD(0, 128, 64);
       
   646 	test(pD.Overlaps(pA));
       
   647 	test(pD.Overlaps(pB));
       
   648 	test(pD.Overlaps(pC));
       
   649 	test.End();
       
   650 	}
       
   651 
       
   652 void SelfTests()
       
   653 	{
       
   654 	test.Next(_L("Running framework unit tests"));
       
   655 	RDmaSession::SelfTest();
       
   656 	TDmaCapability::SelfTest();
       
   657 	TTestCase::SelfTest();
       
   658 	TTransferIter::SelfTest();
       
   659 	TCallbackRecord::SelfTest();
       
   660 	CDmaBmFragmentation::SelfTest();
       
   661 	TAddrRange::SelfTest();
       
   662 	TAddressParms::SelfTest();
       
   663 	test.End();
       
   664 	test.Close();
       
   665 	}