1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 

    17 

    18 /**

    19  @file te_uloggerostv2integsuite_stepbase.cpp

    20  @internalTechnology

    21 */

    22 

    23 #include "te_ostv2integsuite_basewrapper.h"

    24 

    25 #ifdef OST_TRACE_COMPILER_IN_USE

    26 #include "te_instrumentationpoints_enabledTraces.h"

    27 #else

    28 #include "te_instrumentationpoints_disabledTraces.h"

    29 #endif

    30 

    31 

    32 CTe_MCLSuiteBaseWrapper::~CTe_MCLSuiteBaseWrapper()

    33 	{

    34 	iLoggedTraces.ResetAndDestroy();

    35 	iLoggedTraces.Close();

    36 	iSentTraces.ResetAndDestroy();

    37 	iSentTraces.Close();

    38 	}

    39 

    40 CTe_MCLSuiteBaseWrapper::CTe_MCLSuiteBaseWrapper()

    41 	{

    42 	iAlignPosition=-1;

    43 	iNumMatchingTraces=0;

    44 	iPosition=0;

    45 	}

    46 

    47 CTe_MCLSuiteBaseWrapper* CTe_MCLSuiteBaseWrapper::NewLC()

    48 	{

    49 	CTe_MCLSuiteBaseWrapper* self = new (ELeave)CTe_MCLSuiteBaseWrapper();

    50 	CleanupStack::PushL(self);

    51 	self->ConstructL();

    52 	return self;

    53 	}

    54 

    55 CTe_MCLSuiteBaseWrapper* CTe_MCLSuiteBaseWrapper::NewL()

    56 	{

    57 	CTe_MCLSuiteBaseWrapper* self=CTe_MCLSuiteBaseWrapper::NewLC();

    58 	CleanupStack::Pop(); // self;

    59 	return self;

    60 	}

    61 

    62 void CTe_MCLSuiteBaseWrapper::ConstructL()

    63 	{

    64 	}

    65 

    66 TAny* CTe_MCLSuiteBaseWrapper::GetObject()

    67 	{

    68 	return NULL;

    69 	}

    70 TBool CTe_MCLSuiteBaseWrapper::DoCommandL(	const TTEFFunction& /*aCommand*/,

    71 					const TTEFSectionName& /*aSection*/, 

    72 					const TInt /*aAsyncErrorIndex*/)

    73 	{

    74 	return EFalse;

    75 	}

    76 

    77 

    78 

    79 

    80 

    81 TBool CTe_MCLSuiteBaseWrapper::CreateTraceObject(TComponentId aComponentId, TGroupId aGroupId,THasThreadIdentification aHasContext, THasProgramCounter aHasPc,RPointerArray<TTraceConfigs> & aTraceObjects)

    82 	{

    83 	INFO_PRINTF1(_L("-------- Creating Trace configuration object --------"));

    84 	TTraceConfigs* trace = new TTraceConfigs;

    85 	ASSERT(trace);

    86 	TTraceConfigsOperator::Init(*trace);

    87 	TTraceConfigsOperator::SetOptions(*trace, UPTNone, ETrue, ETrue);

    88 	TTraceConfigsOperator::SetHeader(*trace, aGroupId, aComponentId, aHasContext, aHasPc, KTraceId);

    89 	aTraceObjects.Append(trace);

    90 	if(trace && aHasContext)

    91 		{

    92 		trace->iContextId = RThread().BTraceId() + 704; //704 is the offset into the RThread and DThread object until we get to the NThread

    93 		}

    94 	if (trace)

    95 		return ETrue;

    96 		return EFalse;

    97 	}

    98 

    99 TBool CTe_MCLSuiteBaseWrapper::CreateTraceObject(TUPTApiUsed aApi, THasThreadIdentification aHasContext, THasProgramCounter aHasPc,RPointerArray<TTraceConfigs> & aTraceObjects)

   100 	{

   101 	INFO_PRINTF1(_L("-------- Creating Trace configuration object --------"));

   102 	TBool setThreadId = EFalse;

   103 

   104 	switch(aApi)

   105 		{

   106 		//Tests for all kinds of traces in order to make sure all

   107 		//payloads are exactly as wanted depending on what trace api you are using.

   108 		//SetOptions(TTraceConfigs&, TTraceApiUsed, aLoggingEnabled, aTracingBuiltIn);

   109 		//SetHeader(TTraceConfigs&, TGroupId, TComponentId, THasThreadIdentification, THasProgramCounter, TTraceId);

   110 		_LIT8(KStateName,"Test State Name");

   111 		_LIT8(KStateValue,"Test State Value");

   112 		

   113 		case EUptPrintTDesC8_big:

   114 		case EUptKernelPrintfDesc8_big:

   115 			{

   116 			TTraceConfigs* trace = new TTraceConfigs;

   117 			ASSERT(trace);

   118 			TTraceConfigsOperator::Init(*trace);

   119 			TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   120 			TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KFormatPrintf);

   121 			TTraceConfigsOperator::SetData(*trace, KStringDesc8);//TPtrC8((const TUint8*)KBigData8, KBigSize8)

   122 			setThreadId = aHasContext;

   123 			aTraceObjects.Append(trace);

   124 			}

   125 			break;

   126 			

   127 		case EUptPrintTDesC8_huge:

   128 		case EUptKernelPrintfDesc8_huge:

   129 			{

   130 			TTraceConfigs* trace = new TTraceConfigs;

   131 			ASSERT(trace);

   132 			TTraceConfigsOperator::Init(*trace);

   133 			TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   134 			TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KFormatPrintf);

   135 			TTraceConfigsOperator::SetData(*trace, KStringDescHuge8);//TPtrC8((const TUint8*)KHugeData8, KHugeSize8)

   136 			setThreadId = aHasContext;

   137 			aTraceObjects.Append(trace);

   138 			}

   139 			break;

   140 		

   141 			

   142 			

   143 		case EUptPrintTDesC16_big:

   144 #ifndef __KERNEL_MODE__

   145 			{

   146 			TTraceConfigs* trace = new TTraceConfigs;

   147 			ASSERT(trace);

   148 			TTraceConfigsOperator::Init(*trace);

   149 			TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   150 			TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KFormatPrintfUnicode);

   151 			TTraceConfigsOperator::SetData(*trace,KStringDesc16 );//TPtrC16((const TUint16*)KBigData16, KBigSize16)

   152 			setThreadId = aHasContext;

   153 			aTraceObjects.Append(trace);

   154 			}

   155 #endif

   156 			break;

   157 

   158 		case EUptPrintTDesC16_huge:

   159 #ifndef __KERNEL_MODE__

   160 			{

   161 			TTraceConfigs* trace = new TTraceConfigs;

   162 			ASSERT(trace);

   163 			TTraceConfigsOperator::Init(*trace);

   164 			TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   165 			TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KFormatPrintfUnicode);

   166 			TTraceConfigsOperator::SetData(*trace, KStringDescHuge16);//TPtrC16((const TUint16*)KHugeData16, KHugeSize16)

   167 			setThreadId = aHasContext;

   168 			aTraceObjects.Append(trace);

   169 			}

   170 #endif

   171 			break;

   172 

   173 // ***

   174 			

   175 	    case EUptTraceTDesC8_big:

   176             {

   177             TTraceConfigs* trace = new TTraceConfigs;

   178             ASSERT(trace);

   179             TTraceConfigsOperator::Init(*trace);

   180             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   181             TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);

   182             TTraceConfigsOperator::SetData(*trace, KStringDesc8);

   183             setThreadId = aHasContext;

   184             aTraceObjects.Append(trace);

   185             }

   186             break;

   187             

   188         case EUptTraceTDesC8_huge:

   189         case EUptKernelTraceDesc8_huge:

   190             {

   191             TTraceConfigs* trace = new TTraceConfigs;

   192             ASSERT(trace);

   193             TTraceConfigsOperator::Init(*trace);

   194             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   195             TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);

   196             TTraceConfigsOperator::SetData(*trace, KStringDescHuge8);

   197             setThreadId = aHasContext;

   198             aTraceObjects.Append(trace);

   199             }

   200             break;

   201         

   202             

   203             

   204         case EUptTraceTDesC16_big:

   205 #ifndef __KERNEL_MODE__

   206             {

   207             TTraceConfigs* trace = new TTraceConfigs;

   208             ASSERT(trace);

   209             TTraceConfigsOperator::Init(*trace);

   210             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   211             TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);

   212             TTraceConfigsOperator::SetData(*trace,KStringDesc16);

   213             setThreadId = aHasContext;

   214             aTraceObjects.Append(trace);

   215             }

   216 #endif

   217             break;

   218 

   219         case EUptTraceTDesC16_huge:

   220 #ifndef __KERNEL_MODE__

   221             {

   222             TTraceConfigs* trace = new TTraceConfigs;

   223             ASSERT(trace);

   224             TTraceConfigsOperator::Init(*trace);

   225             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   226             TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);

   227             TTraceConfigsOperator::SetData(*trace, KStringDescHuge16);

   228             setThreadId = aHasContext;

   229             aTraceObjects.Append(trace);

   230             }

   231 #endif

   232             break;

   233 

   234 		

   235 		case EUptPrintfchar:

   236 		case EUptKernelPrintfchar:

   237 			{

   238 			TTraceConfigs* trace = new TTraceConfigs;

   239 			ASSERT(trace);

   240 			TTraceConfigsOperator::Init(*trace);

   241 			TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   242 			TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KFormatPrintf);

   243 			TTraceConfigsOperator::SetData(*trace, KPrintfCStyleString, KPrintfCStyleStringSize);

   244 			setThreadId = aHasContext;

   245 			aTraceObjects.Append(trace);

   246 			}

   247 			break;

   248 			

   249         case EUptPrintfTRefByValueTDesC8:

   250             {

   251             TTraceConfigs* trace = new TTraceConfigs;

   252             ASSERT(trace);

   253             TBuf8<42> buf;

   254             buf.AppendFormat(KDesC8Formatted,2);

   255             TTraceConfigsOperator::Init(*trace);

   256             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   257             TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KFormatPrintf);

   258             TTraceConfigsOperator::SetData(*trace, buf);

   259             setThreadId = aHasContext;

   260             aTraceObjects.Append(trace);

   261             }

   262             break;

   263             

   264 		case EUptPrintfTRefByValueTDesC16:

   265 #ifndef __KERNEL_MODE__

   266 			{

   267 			TTraceConfigs* trace = new TTraceConfigs;

   268 			ASSERT(trace);

   269             TBuf16<44> buf;

   270             buf.AppendFormat(KDesCFormatted16,2);

   271 			TTraceConfigsOperator::Init(*trace);

   272 			TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   273 			TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KFormatPrintfUnicode);

   274 			TTraceConfigsOperator::SetData(*trace, buf);

   275 			setThreadId = aHasContext;

   276 			aTraceObjects.Append(trace);

   277 			}

   278 #endif

   279 			break;

   280 		case EUptTrace:

   281 		case EUptKernelTrace:

   282 			{

   283 			TTraceConfigs* trace = new TTraceConfigs;

   284 			ASSERT(trace);

   285 			TTraceConfigsOperator::Init(*trace);

   286 			TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   287 			TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);

   288 			//There is no additional data

   289 			setThreadId = aHasContext;

   290 			aTraceObjects.Append(trace);

   291 			}

   292 			break;

   293 		case EUptTraceTUint32:

   294 		case EUptKernelTraceTUint32:

   295 			{

   296 			TTraceConfigs* trace = new TTraceConfigs;

   297 			ASSERT(trace);

   298 			TTraceConfigsOperator::Init(*trace);

   299 			TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   300 			TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);

   301 			TTraceConfigsOperator::SetData(*trace, KData1);

   302 			setThreadId = aHasContext;

   303 			aTraceObjects.Append(trace);

   304 			}

   305 			break;

   306 		case EUptTraceTUint32TUint32:

   307 		case EUptKernelTraceTUint32TUint32:

   308 			{

   309 			TTraceConfigs* trace = new TTraceConfigs;

   310 			ASSERT(trace);

   311 			TTraceConfigsOperator::Init(*trace);

   312 			TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   313 			TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);

   314 			TTraceConfigsOperator::SetData(*trace, KData1, KData2);

   315 			setThreadId = aHasContext;

   316 			aTraceObjects.Append(trace);

   317 			}

   318 			break;

   319 		case EUptTraceTAnySmallStruct:

   320 		case EUptKernelTraceTAnySmallStruct:

   321 			{

   322 			TTraceConfigs* trace = new TTraceConfigs;

   323 			ASSERT(trace);

   324 			TTraceConfigsOperator::Init(*trace);

   325 			TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   326 			TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);

   327 			TTraceConfigsOperator::SetData(*trace, (TAny*)KSmallData, KSmallSize);

   328 			setThreadId = aHasContext;

   329 			aTraceObjects.Append(trace);

   330 			}

   331 			break;

   332 		case EUptTraceTAnyBigStruct:

   333 		case EUptKernelTraceTAnyBigStruct:

   334 			{

   335 			TTraceConfigs* trace = new TTraceConfigs;

   336 			ASSERT(trace);

   337 			TTraceConfigsOperator::Init(*trace);

   338 			TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   339 			TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);

   340 			TTraceConfigsOperator::SetData(*trace, KBigData8, KBigSize8);

   341 			setThreadId = aHasContext;

   342 			aTraceObjects.Append(trace);

   343 			}

   344 			break;

   345 		case EUptTraceTAnyHugeStruct:

   346 		case EUptKernelTraceTAnyHugeStruct:

   347 			{

   348 			TTraceConfigs* trace = new TTraceConfigs;

   349 			ASSERT(trace);

   350 			TTraceConfigsOperator::Init(*trace);

   351 			TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   352 			TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);

   353 			TTraceConfigsOperator::SetData(*trace, KHugeData8, KHugeSize8);

   354 			setThreadId = aHasContext;

   355 			aTraceObjects.Append(trace);

   356 			}

   357 			break;

   358 		case EUptTraceTemplatedSmallStruct:

   359 		case EUptKernelTraceTemplatedSmallStruct:

   360 			{

   361 			TTraceConfigs* trace = new TTraceConfigs;

   362 			ASSERT(trace);

   363 			TTraceConfigsOperator::Init(*trace);

   364 			TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   365 			TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);

   366 			TTraceConfigsOperator::SetData(*trace, KStructForTemplated);

   367 			setThreadId = aHasContext;

   368 			aTraceObjects.Append(trace);

   369 			}

   370 			break;

   371 		case EUptTraceTemplatedBigStruct:

   372 		case EUptKernelTraceTemplatedBigStruct:

   373 			{

   374 			TTraceConfigs* trace = new TTraceConfigs;

   375 			ASSERT(trace);

   376 			TTraceConfigsOperator::Init(*trace);

   377 			TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   378 			TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);

   379 			TTraceConfigsOperator::SetData(*trace, KBigData8, KBigSize8);

   380 			setThreadId = aHasContext;

   381 			aTraceObjects.Append(trace);

   382 			}

   383 			break;

   384 		case EUptTraceTemplatedHugeStruct:

   385 		case EUptKernelTraceTemplatedHugeStruct:

   386 			{

   387 			TTraceConfigs* trace = new TTraceConfigs;

   388 			ASSERT(trace);

   389 			TTraceConfigsOperator::Init(*trace);

   390 			TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   391 			TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);

   392 			TTraceConfigsOperator::SetData(*trace, KHugeData8, KHugeSize8);

   393 			setThreadId = aHasContext;

   394 			aTraceObjects.Append(trace);

   395 			}

   396 			break;

   397 		case EUptIsTraceActive:

   398 		case EUptKernelIsTraceActive:

   399 			break;

   400 		case UPTTraceTest:

   401 			break;

   402 		case UPTKernelTraceTest:

   403 		case UPTKernelNegativeFunctionalityTest:

   404 			{

   405 			TTraceConfigs* trace1 = new TTraceConfigs;

   406 			ASSERT(trace1);

   407 			TTraceConfigsOperator::Init(*trace1);

   408 			TTraceConfigsOperator::SetOptions(*trace1, aApi, ETrue, ETrue);

   409 			TTraceConfigsOperator::SetHeader(*trace1, KGroupId+1, KComponentId+1, aHasContext, aHasPc, KTraceId);

   410 			aTraceObjects.Append(trace1);

   411 			

   412 			TTraceConfigs* trace2 = new TTraceConfigs;

   413 			ASSERT(trace2);

   414 			TTraceConfigsOperator::Init(*trace2);

   415 			TTraceConfigsOperator::SetOptions(*trace2, aApi, ETrue, ETrue);

   416 			TTraceConfigsOperator::SetHeader(*trace2, KGroupId+2, KComponentId+2, aHasContext, aHasPc, KTraceId);

   417 			aTraceObjects.Append(trace2);

   418 			

   419 			setThreadId = aHasContext;

   420 			}

   421 			break;

   422 		case UPTKernelMultipleFunctionalityTest:

   423 			{

   424 			TTraceConfigs* trace1 = new TTraceConfigs;

   425 			ASSERT(trace1);

   426 			TTraceConfigsOperator::Init(*trace1);

   427 			TTraceConfigsOperator::SetOptions(*trace1, aApi, ETrue, ETrue);

   428 			TTraceConfigsOperator::SetHeader(*trace1, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);

   429 			aTraceObjects.Append(trace1);

   430 			

   431 			TTraceConfigs* trace2 = new TTraceConfigs;

   432 			ASSERT(trace2);

   433 			TTraceConfigsOperator::Init(*trace2);

   434 			TTraceConfigsOperator::SetOptions(*trace2, aApi, ETrue, ETrue);

   435 			TTraceConfigsOperator::SetHeader(*trace2, KGroupId+1, KComponentId, aHasContext, aHasPc, KTraceId);

   436 			aTraceObjects.Append(trace2);

   437 			

   438 			TTraceConfigs* trace3 = new TTraceConfigs;

   439 			ASSERT(trace3);

   440 			TTraceConfigsOperator::Init(*trace3);

   441 			TTraceConfigsOperator::SetOptions(*trace3, aApi, ETrue, ETrue);

   442 			TTraceConfigsOperator::SetHeader(*trace3, KGroupId+2, KComponentId, aHasContext, aHasPc, KTraceId);

   443 			aTraceObjects.Append(trace3);

   444 			

   445 			TTraceConfigs* trace4 = new TTraceConfigs;

   446 			ASSERT(trace4);

   447 			TTraceConfigsOperator::Init(*trace4);

   448 			TTraceConfigsOperator::SetOptions(*trace4, aApi, ETrue, ETrue);

   449 			TTraceConfigsOperator::SetHeader(*trace4, KGroupId, KComponentId+2, aHasContext, aHasPc, KTraceId);

   450 			aTraceObjects.Append(trace4);

   451 			

   452 			TTraceConfigs* trace5 = new TTraceConfigs;

   453 			ASSERT(trace5);

   454 			TTraceConfigsOperator::Init(*trace5);

   455 			TTraceConfigsOperator::SetOptions(*trace5, aApi, ETrue, ETrue);

   456 			TTraceConfigsOperator::SetHeader(*trace5, KGroupId+2, KComponentId+2, aHasContext, aHasPc, KTraceId);

   457 			aTraceObjects.Append(trace5);

   458 			

   459 			TTraceConfigs* trace6 = new TTraceConfigs;

   460 			ASSERT(trace6);

   461 			TTraceConfigsOperator::Init(*trace6);

   462 			TTraceConfigsOperator::SetOptions(*trace6, aApi, ETrue, ETrue);

   463 			TTraceConfigsOperator::SetHeader(*trace6, KGroupId+1, KComponentId+2, aHasContext, aHasPc, KTraceId);

   464 			aTraceObjects.Append(trace6);

   465 			

   466 			TTraceConfigs* trace7 = new TTraceConfigs;

   467 			ASSERT(trace7);

   468 			TTraceConfigsOperator::Init(*trace7);

   469 			TTraceConfigsOperator::SetOptions(*trace7, aApi, ETrue, ETrue);

   470 			aTraceObjects.Append(trace7);

   471 			

   472 			setThreadId = aHasContext;

   473 			}

   474 			break;

   475 			

   476 		//OST	

   477 			

   478         case EOstTraceDef0:

   479             {

   480             TTraceConfigs* trace = new TTraceConfigs;

   481             ASSERT(trace);

   482             TTraceConfigsOperator::Init(*trace);

   483             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   484             TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OstTraceDef0&TRACEIDMASK)>>TRACEIDSHIFT);

   485             //TTraceConfigsOperator::SetData(*trace, TEST_OstTraceDef0); //no additional data

   486             setThreadId = EAddThreadIdentification;

   487             aTraceObjects.Append(trace);                

   488             }

   489             break;        

   490         case EOstTraceDef1:

   491             {

   492             TTraceConfigs* trace = new TTraceConfigs;

   493             ASSERT(trace);

   494             TTraceConfigsOperator::Init(*trace);

   495             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   496             TTraceConfigsOperator::SetHeader(*trace,TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OstTraceDef1&TRACEIDMASK)>>TRACEIDSHIFT);

   497             TTraceConfigsOperator::SetData(*trace, KData1);

   498             setThreadId = EAddThreadIdentification;

   499             aTraceObjects.Append(trace);

   500             }

   501             break;

   502         case EOstTraceDefData:

   503             {

   504             TTraceConfigs* trace = new TTraceConfigs;

   505             ASSERT(trace);

   506             TTraceConfigsOperator::Init(*trace);

   507             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   508             TTraceConfigsOperator::SetHeader(*trace,TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OstTraceDefData&TRACEIDMASK)>>TRACEIDSHIFT);

   509             TTraceConfigsOperator::SetData(*trace, &KData1, sizeof(KData1) );

   510             setThreadId = EAddThreadIdentification;

   511             aTraceObjects.Append(trace);

   512             }

   513             break;

   514         case EOstTraceDefExt1:

   515             {

   516             TTraceConfigs* trace = new TTraceConfigs;

   517             ASSERT(trace);

   518             TTraceConfigsOperator::Init(*trace);

   519             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   520             TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OstTraceDefExt1&TRACEIDMASK)>>TRACEIDSHIFT);

   521             TTraceConfigsOperator::SetData(*trace, (TUint32*)KDefault8().Ptr(),KDefault8().Size());

   522             setThreadId = EAddThreadIdentification;

   523             aTraceObjects.Append(trace);

   524             }

   525             break;         

   526         case EOstTraceDefExt2:

   527             {

   528             TTraceConfigs* trace = new TTraceConfigs;

   529             ASSERT(trace);

   530             TTraceConfigsOperator::Init(*trace);

   531             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   532             TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OstTraceDefExt2&TRACEIDMASK)>>TRACEIDSHIFT);

   533             TTraceConfigsOperator::SetData(*trace, KData1, KData1);

   534             setThreadId = EAddThreadIdentification;

   535             aTraceObjects.Append(trace);

   536             }

   537             break;

   538         case EOstTraceDefExt3:

   539             {

   540             TTraceConfigs* trace = new TTraceConfigs;

   541             ASSERT(trace);

   542             TTraceConfigsOperator::Init(*trace);

   543             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   544             TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OstTraceDefExt3&TRACEIDMASK)>>TRACEIDSHIFT);

   545             TTraceConfigsOperator::SetData(*trace,  KData1, KData1, KData1);

   546             setThreadId = EAddThreadIdentification;

   547             aTraceObjects.Append(trace);

   548             }

   549             break;

   550         case EOstTraceDefExt4:

   551             {

   552             TTraceConfigs* trace = new TTraceConfigs;

   553             ASSERT(trace);

   554             TTraceConfigsOperator::Init(*trace);

   555             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   556             TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OstTraceDefExt4&TRACEIDMASK)>>TRACEIDSHIFT);

   557             TTraceConfigsOperator::SetData(*trace, KData1, KData1, KData1, KData1);

   558             setThreadId = EAddThreadIdentification;

   559             aTraceObjects.Append(trace);

   560             }

   561             break;

   562         case EOstTraceDefExt5:

   563             {

   564             TTraceConfigs* trace = new TTraceConfigs;

   565             ASSERT(trace);

   566             TTraceConfigsOperator::Init(*trace);

   567             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   568             TTraceConfigsOperator::SetHeader(*trace,TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OstTraceDefExt5&TRACEIDMASK)>>TRACEIDSHIFT);

   569             TTraceConfigsOperator::SetData(*trace, KData1, KData1, KData1, KData1, KData1);

   570             setThreadId = EAddThreadIdentification;

   571             aTraceObjects.Append(trace);

   572             }

   573             break;

   574         case EOstTrace0:

   575             {

   576             TTraceConfigs* trace = new TTraceConfigs;

   577             ASSERT(trace);

   578             TTraceConfigsOperator::Init(*trace);

   579             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   580             TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACE0&TRACEIDMASK)>>TRACEIDSHIFT);

   581             //TTraceConfigsOperator::SetData(*trace, TEST_OSTTRACE0);

   582             setThreadId = EAddThreadIdentification;

   583             aTraceObjects.Append(trace);

   584             }

   585             break;

   586         case EOstTrace1:

   587             {

   588             TTraceConfigs* trace = new TTraceConfigs;

   589             ASSERT(trace);

   590             TTraceConfigsOperator::Init(*trace);

   591             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   592             TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACE1&TRACEIDMASK)>>TRACEIDSHIFT);

   593             TTraceConfigsOperator::SetData(*trace,KData1);

   594             setThreadId = EAddThreadIdentification;

   595             aTraceObjects.Append(trace);

   596             }

   597             break;

   598         case EOstTraceData:

   599             {

   600             TTraceConfigs* trace = new TTraceConfigs;

   601             ASSERT(trace);

   602             TTraceConfigsOperator::Init(*trace);

   603             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   604             TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEDATA&TRACEIDMASK)>>TRACEIDSHIFT);

   605             TTraceConfigsOperator::SetData(*trace, &KData1, sizeof(KData1) );

   606             setThreadId = EAddThreadIdentification;

   607             aTraceObjects.Append(trace);

   608             }

   609             break;

   610         case EOstTraceExt1:

   611             {

   612             TTraceConfigs* trace = new TTraceConfigs;

   613             ASSERT(trace);

   614             TTraceConfigsOperator::Init(*trace);

   615             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   616             TTraceConfigsOperator::SetHeader(*trace,TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEEXT1&TRACEIDMASK)>>TRACEIDSHIFT);

   617             TTraceConfigsOperator::SetData(*trace, KData8);

   618             setThreadId = EAddThreadIdentification;

   619             aTraceObjects.Append(trace);

   620             }

   621             break;

   622         case EOstTraceExt2:

   623             {

   624             TTraceConfigs* trace = new TTraceConfigs;

   625             ASSERT(trace);

   626             TTraceConfigsOperator::Init(*trace);

   627             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   628             TTraceConfigsOperator::SetHeader(*trace,TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEEXT2&TRACEIDMASK)>>TRACEIDSHIFT);

   629             TTraceConfigsOperator::SetData(*trace, KData1, KData1);

   630             setThreadId = EAddThreadIdentification;

   631             aTraceObjects.Append(trace);

   632             }

   633             break;

   634         case EOstTraceExt3:

   635             {

   636             TTraceConfigs* trace = new TTraceConfigs;

   637             ASSERT(trace);

   638             TTraceConfigsOperator::Init(*trace);

   639             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   640             TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEEXT3&TRACEIDMASK)>>TRACEIDSHIFT);

   641             TTraceConfigsOperator::SetData(*trace, KData1, KData1, KData1);

   642             setThreadId = EAddThreadIdentification;

   643             aTraceObjects.Append(trace);

   644             }

   645             break;

   646         case EOstTraceExt4:

   647             {

   648             TTraceConfigs* trace = new TTraceConfigs;

   649             ASSERT(trace);

   650             TTraceConfigsOperator::Init(*trace);

   651             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   652             TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEEXT4&TRACEIDMASK)>>TRACEIDSHIFT);

   653             TTraceConfigsOperator::SetData(*trace, KData1, KData1, KData1, KData1);

   654             setThreadId = EAddThreadIdentification;

   655             aTraceObjects.Append(trace);

   656             }

   657             break;

   658         case EOstTraceExt5:

   659             {

   660             TTraceConfigs* trace = new TTraceConfigs;

   661             ASSERT(trace);

   662             TTraceConfigsOperator::Init(*trace);

   663             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   664             TTraceConfigsOperator::SetHeader(*trace,TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEEXT5&TRACEIDMASK)>>TRACEIDSHIFT);

   665             TTraceConfigsOperator::SetData(*trace, KData1, KData1, KData1, KData1, KData1);

   666             setThreadId = EAddThreadIdentification;

   667             aTraceObjects.Append(trace);

   668             }

   669             break;

   670         case EOstTraceFunctionEntry0:

   671             {

   672             TTraceConfigs* trace = new TTraceConfigs;

   673             ASSERT(trace);

   674             TTraceConfigsOperator::Init(*trace);

   675             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   676             TTraceConfigsOperator::SetHeader(*trace, TRACE_FLOW, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTraceFunctionalityEntry0&TRACEIDMASK)>>TRACEIDSHIFT);

   677             //TTraceConfigsOperator::SetData(*trace, TEST_OSTTraceFunctionalityEntry0);

   678             setThreadId = EAddThreadIdentification;

   679             aTraceObjects.Append(trace);

   680             }

   681             break;

   682         case EOstTraceFunctionEntry1:

   683             {

   684             TTraceConfigs* trace = new TTraceConfigs;

   685             ASSERT(trace);

   686             TTraceConfigsOperator::Init(*trace);

   687             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   688             TTraceConfigsOperator::SetHeader(*trace,  TRACE_FLOW, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTraceFunctionalityEntry1&TRACEIDMASK)>>TRACEIDSHIFT);

   689             TTraceConfigsOperator::SetData(*trace, KData1);

   690             setThreadId = EAddThreadIdentification;

   691             aTraceObjects.Append(trace);

   692             }

   693             break;

   694         case EOstTraceFunctionEntryExt:

   695             {

   696             TTraceConfigs* trace = new TTraceConfigs;

   697             ASSERT(trace);

   698             TTraceConfigsOperator::Init(*trace);

   699             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   700             TTraceConfigsOperator::SetHeader(*trace,  TRACE_FLOW, KComponentId, EAddThreadIdentification, ENoProgramCounter, (0x8a0003&TRACEIDMASK)>>TRACEIDSHIFT);

   701             //fix this - should be a list of the function arguments of this method all these traces are insturmented in

   702 			TTraceConfigsOperator::SetData(*trace, KData1);

   703             setThreadId = aHasContext;

   704             aTraceObjects.Append(trace);

   705             }

   706             break;

   707         case EOstTraceFunctionExit0:

   708             {

   709             TTraceConfigs* trace = new TTraceConfigs;

   710             ASSERT(trace);

   711             TTraceConfigsOperator::Init(*trace);

   712             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   713             TTraceConfigsOperator::SetHeader(*trace,  TRACE_FLOW, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OstTraceFunctionExit0&TRACEIDMASK)>>TRACEIDSHIFT);

   714             //TTraceConfigsOperator::SetData(*trace, TEST_OstTraceFunctionExit0);

   715             setThreadId = EAddThreadIdentification;

   716             aTraceObjects.Append(trace);

   717             }

   718             break;

   719         case EOstTraceFunctionExit1:

   720             {

   721             TTraceConfigs* trace = new TTraceConfigs;

   722             ASSERT(trace);

   723             TTraceConfigsOperator::Init(*trace);

   724             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   725             TTraceConfigsOperator::SetHeader(*trace,  TRACE_FLOW, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEFUNCTIONEXIT1&TRACEIDMASK)>>TRACEIDSHIFT);

   726             TTraceConfigsOperator::SetData(*trace, KData1);

   727             setThreadId = EAddThreadIdentification;

   728             aTraceObjects.Append(trace);

   729             }

   730             break;

   731         case EOstTraceFunctionExitExt:

   732             {

   733             TTraceConfigs* trace = new TTraceConfigs;

   734             ASSERT(trace);

   735             TTraceConfigsOperator::Init(*trace);

   736             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   737             TTraceConfigsOperator::SetHeader(*trace,  TRACE_FLOW, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEFUNCTIONEXITEXT&TRACEIDMASK)>>TRACEIDSHIFT);

   738             //fix this

   739 			TTraceConfigsOperator::SetData(*trace, (TUint32)KData1, (TUint32)0);

   740             setThreadId = aHasContext;

   741             aTraceObjects.Append(trace);

   742             }

   743             break;

   744         case EOstTraceEventStart0:

   745             {

   746             TTraceConfigs* trace = new TTraceConfigs;

   747             ASSERT(trace);

   748             TTraceConfigsOperator::Init(*trace);

   749             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   750             TTraceConfigsOperator::SetHeader(*trace, TRACE_PERFORMANCE, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEEVENTSTART0&TRACEIDMASK)>>TRACEIDSHIFT);

   751             TTraceConfigsOperator::SetData(*trace,(TUint32)1);

   752             setThreadId = EAddThreadIdentification;

   753             aTraceObjects.Append(trace);

   754             }

   755             break;

   756         case EOstTraceEventStart1:

   757             {

   758             TTraceConfigs* trace = new TTraceConfigs;

   759             ASSERT(trace);

   760             TTraceConfigsOperator::Init(*trace);

   761             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   762             TTraceConfigsOperator::SetHeader(*trace, TRACE_PERFORMANCE, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEEVENTSTART1&TRACEIDMASK)>>TRACEIDSHIFT);

   763             TTraceConfigsOperator::SetData(*trace, KData1);

   764             setThreadId = EAddThreadIdentification;

   765             aTraceObjects.Append(trace);

   766             }

   767             break;

   768         case EOstTraceEventStop:

   769             {

   770             TTraceConfigs* trace = new TTraceConfigs;

   771             ASSERT(trace);

   772             TTraceConfigsOperator::Init(*trace);

   773             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   774             TTraceConfigsOperator::SetHeader(*trace, TRACE_PERFORMANCE, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEEVENTSTOP&TRACEIDMASK)>>TRACEIDSHIFT);

   775 			TTraceConfigsOperator::SetData(*trace,0,(TUint32)(TEST_OSTTRACEEVENTSTART0 & TRACEIDMASK));

   776             setThreadId = aHasContext;

   777             aTraceObjects.Append(trace);

   778             }

   779             break;

   780         case EOstTraceState0:

   781             {

   782             TTraceConfigs* trace = new TTraceConfigs;

   783             ASSERT(trace);

   784             TTraceConfigsOperator::Init(*trace);

   785             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   786             TTraceConfigsOperator::SetHeader(*trace, TRACE_STATE, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACESTATE0&TRACEIDMASK)>>TRACEIDSHIFT);

   787             TTraceConfigsOperator::SetData(*trace, KStateName,KStateValue);

   788             setThreadId = EAddThreadIdentification;

   789             aTraceObjects.Append(trace);

   790             }

   791             break;

   792         case EOstTraceState1:

   793             {

   794             TTraceConfigs* trace = new TTraceConfigs;

   795             ASSERT(trace);

   796             TTraceConfigsOperator::Init(*trace);

   797             TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);

   798             TTraceConfigsOperator::SetHeader(*trace, TRACE_STATE, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACESTATE1&TRACEIDMASK)>>TRACEIDSHIFT);

   799             TTraceConfigsOperator::SetData(*trace, KStateName,KStateValue,KData1);

   800             setThreadId = EAddThreadIdentification;

   801             aTraceObjects.Append(trace);

   802             }

   803             break;

   804 		default:

   805 			//delete trace;

   806 			//trace = NULL;

   807 			break;

   808 		}

   809 	

   810 	for(TInt i = 0; i <= (aTraceObjects.Count()-1); i++)

   811 		{

   812 		if(aTraceObjects[i] && setThreadId)

   813 			{

   814 			aTraceObjects[i]->iContextId = RThread().BTraceId() + 704; //704 is the offset into the RThread and DThread object until we get to the NThread

   815 			}

   816 		}

   817 	

   818 	TBool realTrace=EFalse;

   819 	if (aTraceObjects.Count())

   820 		{

   821 		realTrace=ETrue;

   822 		}

   823 	switch(aApi)

   824 	{

   825 	case UPTTraceTest:

   826 	case UPTKernelTraceTest:

   827 	case UPTKernelNegativeFunctionalityTest:

   828 	case UPTKernelMultipleFunctionalityTest:

   829 	case UPTBaseline:

   830 	case UPTKernelBaseline:

   831 	case UPTFooUserTime:

   832 	case UPTFooKernelTime:

   833 		realTrace = EFalse;

   834 	break;

   835 	default:

   836 	break;

   837 	}

   838 	

   839 	return realTrace;	

   840 	}

   841 

   842 TInt CTe_MCLSuiteBaseWrapper::StoreTraceInfo(TBool aEnumBased,TUPTApiUsed anApi,TComponentId aComponentId, TGroupId aGroupId,THasThreadIdentification aHasContext, THasProgramCounter aHasPc)

   843 	{

   844 	INFO_PRINTF1(_L("-------- Storing trace information --------"));

   845 	TInt lastError = KErrNone;

   846 	RPointerArray<TTraceConfigs> traceObjects(10);

   847 	TBool realTrace=EFalse;

   848 	

   849 	if (aEnumBased)

   850 		{

   851 		realTrace=CreateTraceObject(anApi,aHasContext,aHasPc,traceObjects);

   852 		}

   853 	else

   854 		{

   855 		realTrace=CreateTraceObject(aComponentId, aGroupId,aHasContext, aHasPc, traceObjects);

   856 		}

   857 

   858 			

   859 	if(traceObjects.Count()&&realTrace)

   860 		{

   861 		for(TInt i = 0; i <=(traceObjects.Count()-1); i++)

   862 			{

   863 			iSentTraces.Append(traceObjects[i]);

   864 			}

   865 		}

   866 			

   867 	if (!realTrace)

   868 		{

   869 		lastError=KErrNone;

   870 		INFO_PRINTF3(_L("INFO: Trace object (TTraceConfigs) not created, because no actual trace sent error %i, API %i. "), lastError,anApi);

   871 		}

   872 	traceObjects.Reset();

   873 	return lastError;

   874 	}

   875 

   876 void CTe_MCLSuiteBaseWrapper::CreateTraceHeaderObject(TComponentId aComponentId, TGroupId aGroupId,THasThreadIdentification aHasContext, THasProgramCounter aHasPc,TTraceHeaderInfo*& aHeaderInfo)

   877 	{

   878 	//INFO_PRINTF1(_L("-------- Creating Trace header object --------"));

   879 	TTraceConfigsOperator::Init(*aHeaderInfo);

   880 	TTraceConfigsOperator::SetHeader(*aHeaderInfo, aGroupId, aComponentId, aHasContext, aHasPc, KInitialClientFormat);

   881 	if(aHasContext)

   882 		{

   883 		aHeaderInfo->iContextId = RThread().BTraceId() + 704; //704 is the offset into the RThread and DThread object until we get to the NThread

   884 		}

   885 	}

   886 

   887 TInt CTe_MCLSuiteBaseWrapper::StoreTraceHeaderInfo(TComponentId aComponentId, TGroupId aGroupId,THasThreadIdentification aHasContext, THasProgramCounter aHasPc)

   888 	{

   889 	//INFO_PRINTF1(_L("-------- Storing trace header information --------"));

   890 	TInt lastError = KErrNone;

   891 	TTraceHeaderInfo* headerInfo= new TTraceHeaderInfo;

   892 	ASSERT(headerInfo);

   893 	CreateTraceHeaderObject(aComponentId, aGroupId,aHasContext, aHasPc, headerInfo);

   894 

   895 	TRAP(lastError,(iSentTraceHeaders->AppendL(headerInfo)));

   896 	if (lastError)

   897 		{

   898 		INFO_PRINTF2(_L("Error: Unable to append trace header object to array. error: %i "), lastError);

   899 		delete headerInfo;

   900 		}

   901 

   902 	return lastError;

   903 	}

   904 

   905 TInt CTe_MCLSuiteBaseWrapper::ReadFromLogFile(const TDesC& aFileName)

   906 	{

   907 	INFO_PRINTF2(_L("-------- Reading from log file -------- %S"), &aFileName);

   908 	//read data...

   909 	TUint 		bufferSize = 0;

   910 	TUint8*		traceBuffer = NULL;

   911 	

   912 	

   913 	TRAPD(error, (error = GetDataL(traceBuffer, bufferSize, aFileName)));

   914 	if(!bufferSize || error)

   915 		{

   916 		INFO_PRINTF2(_L("ERROR: Error reading from logfile %i. "), error);

   917 		return error;

   918 		}

   919 	// process all the complete traces in buffer...

   920 	error = iParser.ParseRawBuffer(traceBuffer, bufferSize, iLoggedTraces);

   921 	INFO_PRINTF2(_L("Number of additional traces (not sent from test suite) is %d"),iParser.iNumSystemTraces);

   922 	delete traceBuffer; //done with it, so delete it

   923 	return error;

   924 	}

   925 

   926 TInt CTe_MCLSuiteBaseWrapper::ReadHeaderFromLogFile(const TDesC& aFileName)

   927 	{

   928 	INFO_PRINTF1(_L("-------- Reading headers info from log file --------"));

   929 	TUint 		bufferSize = 1;

   930 	TUint8*		traceBuffer = NULL;

   931 	TUint		position= 0;

   932 	iHeaderParser.iNumSystemTraces=0;

   933 	iPosition=0;

   934 	iAlignPosition=-1;

   935 	iNumMatchingTraces=0;

   936 	TInt error=KErrNone;

   937 	//read data...

   938 	while (bufferSize&&!error)

   939 		{

   940 		TRAP(error, (error = GetDataL(traceBuffer, bufferSize, position, aFileName)));

   941 		if(!bufferSize || error)

   942 			{

   943 			INFO_PRINTF2(_L("ERROR: Error reading from logfile %i. "), error);

   944 			if (traceBuffer)

   945 				delete traceBuffer;

   946 			break;

   947 			}

   948 		// process all the complete traces in buffer...

   949 		error = iHeaderParser.ParseRawBuffer(traceBuffer, bufferSize, iLoggedTraceHeaders);

   950 		if (error)

   951 			INFO_PRINTF2(_L("ERROR: Error parsing info from logfile %i. "), error);

   952 		delete traceBuffer; //done with it for now, so delete it (GetDataL() always allocates new memory)

   953 		if (!error)

   954 			CompareTraceHeaders();

   955 		for (TInt i=0; i<iLoggedTraceHeaders->Count(); i++)

   956 			{

   957 			delete iLoggedTraceHeaders->At(i);

   958 			}

   959 		iLoggedTraceHeaders->Delete(0,iLoggedTraceHeaders->Count()); //empty out array to save space

   960 		

   961 		if (iSentTraceHeaders->Count()>=1)

   962 			{

   963 			for (TInt i=0; i<iPosition; i++)

   964 				{

   965 				delete iSentTraceHeaders->At(i);

   966 				}

   967 			iSentTraceHeaders->Delete(0,iPosition);

   968 			iSentTraceHeaders->Compress();

   969 			}

   970 		iPosition=0;

   971 		position+=bufferSize;

   972 		}

   973 	INFO_PRINTF2(_L("Number of additional traces (not sent from test suite) is %d"),iHeaderParser.iNumSystemTraces);

   974 	INFO_PRINTF2(_L("Number of matching traces is %d"),iNumMatchingTraces);

   975 	INFO_PRINTF2(_L("Position of alignment is %d"),iAlignPosition);

   976 	return error;

   977 	}

   978 

   979 TInt CTe_MCLSuiteBaseWrapper::CompareTraces()

   980 	{

   981 	INFO_PRINTF1(_L("-------- Comparing Traces --------"));

   982 	TInt error = KErrNone;

   983 	if(iLoggedTraces.Count() != iSentTraces.Count())

   984 		{

   985 		INFO_PRINTF3(_L("ERROR: Different amount of traces written (%i) and read (%i). "), iSentTraces.Count(), iLoggedTraces.Count());

   986 		error = KErrCorrupt;//will be ignored..

   987 		}

   988 	

   989 	TInt count = 0;

   990 	if(iLoggedTraces.Count() > iSentTraces.Count())

   991 		count = iSentTraces.Count();

   992 	else

   993 		count = iLoggedTraces.Count();

   994 		

   995 	for(TInt i = 0; i < count; i++)

   996 		{

   997 		TTraceConfigs* logged = iLoggedTraces[i];

   998 		TTraceConfigs* sent = iSentTraces[i];

   999 		

  1000 		INFO_PRINTF2(_L("--- Trace %i ---"), sent->iApiUsed);

  1001 		

  1002 		//module uid ...

  1003 		if(logged->iComponentId == sent->iComponentId)

  1004 			INFO_PRINTF2(_L("ComponentId %i          - ok"), sent->iComponentId);

  1005 		else

  1006 			{

  1007 			INFO_PRINTF3(_L("ComponentId             - ERROR: sent %i, logged %i"), sent->iComponentId, logged->iComponentId);

  1008 			error = KErrCorrupt;

  1009 			}

  1010 

  1011 		//GroupId ...

  1012 		if(logged->iGroupId == sent->iGroupId)

  1013 			INFO_PRINTF2(_L("GroupId %i     - ok"), logged->iGroupId);

  1014 		else

  1015 			{

  1016 			INFO_PRINTF3(_L("GroupId        - ERROR: sent %i, logged %i"), sent->iGroupId, logged->iGroupId); 

  1017 			error = KErrCorrupt;

  1018 			}

  1019 

  1020 		//sub-category ...

  1021 		if(logged->iSubCategory == sent->iSubCategory)

  1022 			INFO_PRINTF2(_L("SubCategory %i        - ok"), sent->iSubCategory);

  1023 		else

  1024 			{

  1025 			INFO_PRINTF3(_L("SubCategory           - ERROR: sent %i, logged %i"), sent->iSubCategory, logged->iSubCategory);

  1026 			error = KErrCorrupt;

  1027 			}

  1028 		

  1029 		//format id ...

  1030 		if(logged->iTraceId == sent->iTraceId)

  1031 			{

  1032 			INFO_PRINTF2(_L("TraceId %i           - ok"), sent->iTraceId);

  1033 			}

  1034 		else

  1035 			{

  1036 			INFO_PRINTF3(_L("TraceId             - ERROR: sent %i, logged %i"), sent->iTraceId, logged->iTraceId);

  1037 			error = KErrCorrupt;

  1038 			}

  1039 		

  1040 		//context id present ...

  1041 		if(logged->iHasThreadId == sent->iHasThreadId)

  1042 			INFO_PRINTF2(_L("ContextId included %i - ok"), (TInt) sent->iHasThreadId);

  1043 		else

  1044 			{

  1045 			INFO_PRINTF3(_L("ContextId included    - ERROR: sent %i, logged %i"), sent->iHasThreadId, logged->iHasThreadId);

  1046 			error = KErrCorrupt;

  1047 			}

  1048 	

  1049 		//pc present ...

  1050 		if(logged->iHasProgramCounter == sent->iHasProgramCounter)

  1051 			INFO_PRINTF2(_L("Pc included %i        - ok"), (TInt) sent->iHasProgramCounter);

  1052 		else

  1053 			{

  1054 			INFO_PRINTF3(_L("Pc included           - ERROR: sent %i, logged %i"), sent->iHasProgramCounter, logged->iHasProgramCounter);

  1055 			error = KErrCorrupt;

  1056 			}

  1057 		

  1058 		//context id value ...

  1059 		if(sent->iContextId == logged->iContextId)

  1060 			INFO_PRINTF2(_L("ContextId value 0x%x  - ok"), (TInt) sent->iContextId);

  1061 		else

  1062 			{

  1063 			//INFO_PRINTF3(_L("ContextId value       - ERROR: sent 0x%x, logged 0x%x"), sent->iContextId, logged->iContextId);

  1064 			//INFO_PRINTF1(_L("Integration test suite does not support checking of context ID - this is done in the unit test suite"));

  1065 			//error = KErrCorrupt; 

  1066 			}

  1067 

  1068 		//pc value...	

  1069 		if(sent->iPc == logged->iPc)

  1070 			INFO_PRINTF2(_L("Pc value 0x%x         - ok"), (TInt) sent->iPc);

  1071 		else

  1072 			{

  1073 			//not set to be corrupt now because PC  isn't working properly yet

  1074 			INFO_PRINTF3(_L("Pc value              - ERROR: sent 0x%x, logged 0x%x"), sent->iPc, logged->iPc);

  1075 			//error = KErrCorrupt;

  1076 			}

  1077 		

  1078 		//payload ...

  1079 		TInt j = sizeof(sent->iRawData)/4 - 1;

  1080 		TBool payloadIsEqual = ETrue;

  1081 		while(j >= 0)

  1082 			{			

  1083 			if(sent->iRawData[j] != logged->iRawData[j])

  1084 				{

  1085 				payloadIsEqual = EFalse;

  1086 				break; //bad payload 

  1087 				}

  1088 			j--;

  1089 			}

  1090 		if(payloadIsEqual)

  1091 			INFO_PRINTF2(_L("Payload \"%s\"        - ok"), sent->iRawData);

  1092 		else

  1093 			{

  1094 			TUint16* sentPtr = (TUint16*) sent->iRawData;

  1095 			TUint16* loggedPtr = (TUint16*) logged->iRawData;

  1096 			INFO_PRINTF3(_L("Payload               - ERROR: sent \"%s\", logged \"%s\""), sentPtr, loggedPtr);

  1097 			INFO_PRINTF7(_L("Payload               - sent   [0x%x][0x%x][0x%x][0x%x][0x%x][0x%x]"), sent->iRawData[0],sent->iRawData[1],sent->iRawData[2],sent->iRawData[3],sent->iRawData[4],sent->iRawData[5]);

  1098 			INFO_PRINTF7(_L("Payload               - logged [0x%x][0x%x][0x%x][0x%x][0x%x][0x%x]"), logged->iRawData[0], logged->iRawData[1], logged->iRawData[2], logged->iRawData[3], logged->iRawData[4], logged->iRawData[5]);

  1099 			error = KErrCorrupt;

  1100 			}

  1101 		}

  1102 	return error;

  1103 	}

  1104 

  1105 TInt CTe_MCLSuiteBaseWrapper::CompareTraceHeaders()

  1106 	{

  1107 	TInt error = KErrCorrupt;

  1108 		

  1109 	for(TInt i = iPosition; ((error!=KErrNone)&&(iSentTraceHeaders->Count()>iPosition)); i++)

  1110 		{

  1111 		

  1112 		if (iLoggedTraceHeaders->Count()==0)

  1113 			{

  1114 			INFO_PRINTF1(_L("iLoggedTraceHeaders array is empty"));

  1115 			break;

  1116 			}

  1117 		TTraceHeaderInfo* logged = iLoggedTraceHeaders->At(0);

  1118 		TTraceHeaderInfo* sent = iSentTraceHeaders->At(i);

  1119 		

  1120 		//module uid ...

  1121 		if(logged->iComponentId == sent->iComponentId)

  1122 			{

  1123 			error = KErrNone;

  1124 			}

  1125 		else

  1126 			{

  1127 			error = KErrCorrupt;

  1128 			}

  1129 

  1130 		//GroupId ...

  1131 		if(logged->iGroupId == sent->iGroupId){}

  1132 		else

  1133 			{

  1134 			error = KErrCorrupt;