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 // Ost Performance Tests Ost Call.

    15 //

    16 

    17 

    18 

    19 /**

    20  @file te_instrumentationpoints_disabled.cpp

    21  @internalTechnology

    22  @prototype

    23 */

    24 

    25 

    26 #include "te_instrumentationpoints.h"

    27 #include "te_instrumentationpoints_disabledTraces.h"

    28 #ifndef __KERNEL_MODE__

    29 #include <e32base.h> //for cleanupstack

    30 #endif

    31 

    32 #include "te_perfstackinfo.h"

    33 #include "te_dataparameters.h"

    34 #include "sanity/te_perfsanityhelpers.h"

    35 

    36 

    37 

    38 

    39 /*dummy function for Test function - used to calibrate and debug the timer class with the Lauterbach*/

    40 void tracefoo()

    41 	 {

    42 	 volatile int gt[100]; //expect 400 bytes stack use - i.e. 100 words of 4bytes each

    43 		for(int i=0; i<100;++i)

    44 			gt[i] = i;

    45 	 }

    46 

    47 

    48 TBool TUptTraceCalls::IsKernelTrace(TInt aApiId)

    49 	{

    50 	TBool isKernelTrace = EFalse;

    51 	switch(aApiId)

    52 	{

    53 		case EUptKernelPrintfchar:

    54 		case EUptKernelPrintfDesc8_big:

    55 		case EUptKernelPrintfDesc8_huge:

    56 		case EUptKernelTrace:

    57 		case EUptKernelTraceTUint32:

    58 		case EUptKernelTraceTUint32TUint32:

    59 		case EUptKernelTraceTAnySmallStruct:

    60 		case EUptKernelTraceTAnyBigStruct:

    61 		case EUptKernelTraceTAnyHugeStruct:

    62 		case EUptKernelTraceTemplatedSmallStruct:

    63 		case EUptKernelTraceTemplatedBigStruct:

    64 		case EUptKernelTraceTemplatedHugeStruct:

    65 		case EUptKernelIsTraceActive:

    66 		case UPTKernelTraceTest:

    67 		case UPTKernelNegativeFunctionalityTest:

    68 		case UPTKernelMultipleFunctionalityTest:

    69 		case UPTKernelBaseline:

    70 		isKernelTrace = ETrue;

    71 		break;

    72 		default:

    73 		break;

    74 		}

    75 	return isKernelTrace;

    76 	}

    77 

    78 TInt TUptTraceCalls::DoSendTraceL(const TApiRunConfig& aApiRunConfig, TApiRunResults& aApiRunResults)

    79 	{

    80 	TInt error = KErrGeneral;

    81 	TBool logged = EFalse;

    82 	TUint32 stackbase=0;

    83 	TUint32 before=0;

    84 	aApiRunResults.iApiStackUsage = 0;

    85 	

    86     switch(aApiRunConfig.iApiId)

    87 	{		

    88 		

    89 	case EUptPrintTDesC8_big:

    90 	case EUptKernelPrintfDesc8_big:

    91 		{

    92 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

    93 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

    94 		logged = OstPrint(attributes, KStringDesc8 );//TPtrC8((const TUint8*)KBigData8, KBigSize8)

    95 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

    96 		}

    97 	break;

    98 

    99 	case EUptPrintTDesC8_huge:

   100 	case EUptKernelPrintfDesc8_huge:

   101 		{

   102 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   103 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   104 		logged = OstPrint(attributes, KStringDescHuge8);//TPtrC8((const TUint8*)KHugeData8, KHugeSize8)

   105 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   106 		}

   107 	break;

   108 		

   109 	case EUptPrintTDesC16_big:

   110 #ifndef __KERNEL_MODE__

   111 		{

   112 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   113 		TTraceContext attributes(KComponentId, KGroupId,  aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   114 		logged = OstPrint(attributes, KStringDesc16);//TPtrC16((const TUint16*)KBigData16, KBigSize16)

   115 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   116 		}

   117 #endif	

   118 	break;

   119 		

   120 	case EUptPrintTDesC16_huge:

   121 #ifndef __KERNEL_MODE__

   122 		{

   123 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   124 		TTraceContext attributes(KComponentId, KGroupId,  aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   125 		logged = OstPrint(attributes, KStringDescHuge16);//TPtrC16((const TUint16*)KHugeData16, KHugeSize16)

   126 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   127 		}

   128 #endif	

   129 	break;

   130 	

   131 	

   132 	case EUptTraceTDesC8_big:

   133 	case EUptKernelTraceDesc8_big:

   134 		{

   135 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   136 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   137 		logged = OstTrace(attributes, KTraceId, KStringDesc8);//TPtrC8((const TUint8*)KBigData8, KBigSize8));

   138 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   139 		}

   140 	break;

   141 

   142 	case EUptTraceTDesC8_huge:

   143 	case EUptKernelTraceDesc8_huge:

   144 		{

   145 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   146 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   147 		logged = OstTrace(attributes, KTraceId, KStringDescHuge8);//TPtrC8((const TUint8*)KHugeData8, KHugeSize8));

   148 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   149 		}

   150 	break;

   151 	

   152 

   153 	

   154 	case EUptTraceTDesC16_big:

   155 #ifndef __KERNEL_MODE__

   156 		{

   157 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   158 		TTraceContext attributes(KComponentId, KGroupId,  aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   159 		logged = OstTrace(attributes, KTraceId, KStringDesc16);//TPtrC16((const TUint16*)KBigData16, KBigSize16));

   160 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   161 		}

   162 #endif	

   163 	break;

   164 

   165 	case EUptTraceTDesC16_huge:

   166 #ifndef __KERNEL_MODE__

   167 		{

   168 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   169 		TTraceContext attributes(KComponentId, KGroupId,  aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   170 		logged = OstTrace(attributes, KTraceId, KStringDescHuge16);//TPtrC16((const TUint16*)KHugeData16, KHugeSize16));

   171 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   172 		}

   173 #endif	

   174 	break;

   175 	

   176 	

   177 	case EUptPrintfchar:

   178 	case EUptKernelPrintfchar:

   179 		{

   180 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   181 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   182 		logged = OstPrintf(attributes, KPrintfCStyleString);

   183 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   184 		}

   185 	break;

   186 

   187 	case EUptPrintfTRefByValueTDesC8:

   188 	case EUptKernelPrintfTRefByValueTDesC8:

   189 	    {

   190 	    __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   191 	    TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   192 	    logged = OstPrintf(attributes, KDesC8Formatted,2);

   193 	    __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   194 	    }

   195 

   196 	break;

   197 	case EUptPrintfTRefByValueTDesC16:

   198 #ifndef __KERNEL_MODE__

   199 		{

   200 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   201 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   202 		logged = OstPrintf(attributes, KDesCFormatted16,2);

   203 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   204 		}

   205 #endif

   206 	break;

   207 		

   208 	case EUptTrace:

   209 	case EUptKernelTrace:

   210 		{

   211 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   212 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   213 		logged = OstTrace(attributes, KTraceId);

   214 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   215 		}

   216 	break;

   217 		

   218 	case EUptTraceTUint32:

   219 	case EUptKernelTraceTUint32:

   220 		{

   221 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   222 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   223 		logged = OstTrace(attributes, KTraceId, KData1);

   224 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   225 		}

   226 	break;

   227 		

   228 	case EUptTraceTUint32TUint32:

   229 	case EUptKernelTraceTUint32TUint32:

   230 		{

   231 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   232 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   233 		logged = OstTrace(attributes, KTraceId, KData1, KData2);

   234 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);				

   235 		}

   236 	break;

   237 		

   238 	case EUptTraceTAnySmallStruct:

   239 	case EUptKernelTraceTAnySmallStruct:

   240 		{

   241 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   242 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   243 		logged = OstTrace(attributes, KTraceId, KSmallData, KSmallSize);

   244 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   245 		}

   246 	break;

   247 	case EUptTraceTAnyBigStruct:

   248 	case EUptKernelTraceTAnyBigStruct:

   249 		{

   250 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   251 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   252 		logged = OstTrace(attributes, KTraceId, KBigData8, KBigSize8);

   253 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   254 		}

   255 	break;

   256 

   257 	case EUptTraceTAnyHugeStruct:

   258 	case EUptKernelTraceTAnyHugeStruct:

   259 		{

   260 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   261 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   262 		logged = OstTrace(attributes, KTraceId, KHugeData8, KHugeSize8);

   263 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   264 		}

   265 	break;

   266 		

   267 	

   268 	case EUptTraceTemplatedSmallStruct:

   269 	case EUptKernelTraceTemplatedSmallStruct:

   270 		{

   271 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   272 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   273 		logged = OstTrace(attributes, KTraceId, KStructForTemplated);

   274 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   275 		}

   276 	break;

   277 	

   278 	case EUptTraceTemplatedBigStruct:

   279 	case EUptKernelTraceTemplatedBigStruct:

   280 		{

   281 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   282 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   283 		logged = OstTrace(attributes, KTraceId, KBigData8);

   284 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   285 		}

   286 	break;

   287 	

   288 	case EUptTraceTemplatedHugeStruct:

   289 	case EUptKernelTraceTemplatedHugeStruct:

   290 		{

   291 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   292 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   293 		logged = OstTrace(attributes, KTraceId, KHugeData8);

   294 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   295 		}

   296 	break;

   297 		

   298 	case EUptIsTraceActive:

   299 	case EUptKernelIsTraceActive:

   300 		{

   301 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   302 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   303 		logged = IsTraceActive(attributes);

   304 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   305 		}

   306 	break;

   307 		

   308 

   309 	case UPTTraceTest:

   310 	case UPTKernelTraceTest:

   311 		{

   312 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   313 		SanityFoo();

   314 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   315 		}

   316 	break;

   317 	

   318 	case UPTKernelNegativeFunctionalityTest:

   319 		{

   320 		logged = OstTrace(TTraceContext(KComponentId+1, KGroupId+1, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter), KTraceId);

   321 		logged = OstTrace(TTraceContext(KComponentId+2, KGroupId+2, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter), KTraceId);

   322 		}

   323 	break;

   324 	

   325 	case UPTKernelMultipleFunctionalityTest:

   326 		{

   327 		logged = OstTrace(TTraceContext(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter), KTraceId);

   328 		logged = OstTrace(TTraceContext(KComponentId + 1, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter), KTraceId);

   329 		logged = OstTrace(TTraceContext(KComponentId + 2, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter), KTraceId);

   330 		logged = OstTrace(TTraceContext(KComponentId, KGroupId + 2, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter), KTraceId);

   331 		logged = OstTrace(TTraceContext(KComponentId + 2, KGroupId + 2, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter), KTraceId);

   332 		logged = OstTrace(TTraceContext(KComponentId + 1, KGroupId + 2, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter), KTraceId);

   333 		logged = OstTrace(TTraceContext(KComponentId, KGroupId + 1, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter), KTraceId);

   334 		}

   335 		break;

   336 		

   337 	case BTraceFiltered4:

   338 		{

   339 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   340 		logged = BTraceFiltered4(KGroupId,0 ,KComponentId);

   341 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   342 		}

   343 	break;

   344 	case BTraceFiltered8:

   345 		{

   346 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   347 		logged = BTraceFiltered8(KGroupId,0 ,KComponentId,KData1);

   348 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   349 		}

   350 	break;

   351 	case BTraceFiltered12:

   352 		{

   353 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   354 		logged = BTraceFiltered12(KGroupId,0 ,KComponentId,KData1,KData2);

   355 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   356 		}

   357 	

   358 	break;

   359 	case BTraceFilteredBig:

   360 		{

   361 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   362 		logged = BTraceFilteredBig(KGroupId,0 ,KComponentId,KHugeData8,sizeof(KHugeData8));

   363 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   364 		}

   365 	break;

   366 	case BTrace0:

   367 		{

   368 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   369 		logged = BTrace0(KGroupId,0 );

   370 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   371 		}

   372 	break;

   373 	case BTrace4:

   374 		{

   375 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   376 		logged = BTrace4(KGroupId,0 ,KData1);

   377 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);						

   378 		}

   379 	break;

   380 	case BTrace8:

   381 		{

   382 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   383 		logged = BTrace8(KGroupId,0 ,KData1, KData2);

   384 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);		

   385 		}

   386 	break;

   387 	case BTrace12:

   388 		{

   389 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   390 		logged = BTrace12(KGroupId,0 ,KData1, KData2, KData3);

   391 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);		

   392 		}

   393 	break;		

   394 	case UPTKernelBaseline:

   395 	case UPTBaseline:

   396 		{

   397 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   398 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   399 		}

   400 	break;

   401 	

   402     case EOstTraceDef0:

   403         {

   404         /**

   405         Preprocessor level for all traces on. 

   406         This should not be used from traces

   407         */

   408         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   409         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   410         OstTraceDef0( OST_TRACE_CATEGORY_ALL, TRACE_FATAL, TEST_OstTraceDef0, "EOstTraceDef0" ) ;

   411         logged = EFalse;

   412         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   413         }

   414     break;

   415     

   416     case EOstTraceDef1:

   417         {

   418         /**

   419         Preprocessor level for all traces on. 

   420         This should not be used from traces

   421         */

   422         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   423         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   424         OstTraceDef1( OST_TRACE_CATEGORY_ALL, TRACE_FATAL, TEST_OstTraceDef1, "EOstTraceDef1 - %u" , KData1) ;

   425         logged = EFalse;

   426         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);  

   427             

   428         }

   429     break;

   430     

   431     case EOstTraceDefData:

   432         {

   433         /**

   434         Preprocessor level for all traces on. 

   435         This should not be used from traces

   436         */

   437         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   438         //const TAny* y = &KData1;

   439         

   440         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   441         OstTraceDefData( OST_TRACE_CATEGORY_ALL, TRACE_FATAL, TEST_OstTraceDefData, "EOstTraceDefData", &KData1, sizeof(KData1) ) ;

   442         logged = EFalse;

   443         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   444 

   445         }

   446     break;

   447     

   448     case EOstTraceDefExt1:

   449         {

   450         /**

   451         Preprocessor level for all traces on. 

   452         This should not be used from traces

   453         */

   454         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   455         

   456         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   457         OstTraceDefExt1( OST_TRACE_CATEGORY_ALL, TRACE_FATAL, TEST_OstTraceDefExt1, "OstTraceDefExt1 - %s", KDefault8 ) ;

   458         logged = EFalse;

   459         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   460 

   461         }

   462     break;

   463     

   464     case EOstTraceDefExt2:

   465         {

   466         /**

   467         Preprocessor level for all traces on. 

   468         This should not be used from traces

   469         */

   470         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   471         

   472         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   473         

   474         OstTraceDefExt2( OST_TRACE_CATEGORY_ALL, TRACE_FATAL, TEST_OstTraceDefExt2, "OstTraceDefExt2 - %u - %u", KData1 , KData1) ;

   475         logged = EFalse;

   476         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   477 

   478         }

   479     break;

   480     

   481     case EOstTraceDefExt3:

   482         {

   483         /**

   484         Preprocessor level for all traces on. 

   485         This should not be used from traces

   486         */

   487         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   488         

   489         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   490         

   491         OstTraceDefExt3( OST_TRACE_CATEGORY_ALL, TRACE_FATAL, TEST_OstTraceDefExt3, "OstTraceDefExt3 - %u - %u - %u", KData1 , KData1, KData1) ;

   492         logged = EFalse;

   493         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   494 

   495         }

   496     break;

   497     

   498     case EOstTraceDefExt4:

   499         {

   500         /**

   501         Preprocessor level for all traces on. 

   502         This should not be used from traces

   503         */

   504         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   505         

   506         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   507         

   508         OstTraceDefExt4( OST_TRACE_CATEGORY_ALL, TRACE_FATAL, TEST_OstTraceDefExt4, "OstTraceDefExt4 - %u - %u - %u - %u", KData1 , KData1, KData1, KData1) ;

   509         logged = EFalse;

   510         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   511 

   512         }

   513     break;

   514     

   515     case EOstTraceDefExt5:

   516         {

   517         /**

   518         Preprocessor level for all traces on. 

   519         This should not be used from traces

   520         */

   521         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   522         

   523         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   524         

   525         OstTraceDefExt5( OST_TRACE_CATEGORY_ALL, TRACE_FATAL, TEST_OstTraceDefExt5, "OstTraceDefExt5 - %u - %u - %u - %u - %u", KData1, KData1, KData1, KData1, KData1 ) ;

   526         logged = EFalse;

   527         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   528 

   529         }

   530     break;

   531     

   532     case EOstTrace0:

   533         {

   534         /**

   535         Preprocessor level for all traces on. 

   536         This should not be used from traces

   537         */

   538         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   539         

   540         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   541         OstTrace0( TRACE_FATAL, TEST_OSTTRACE0, "EOstTrace0" );

   542         logged = EFalse;

   543         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   544         }

   545     break;

   546     

   547     case EOstTrace1:

   548         {

   549         /**

   550         Preprocessor level for all traces on. 

   551         This should not be used from traces

   552         */

   553         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   554         

   555         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   556         OstTrace1( TRACE_FATAL, TEST_OSTTRACE1, "EOstTrace1  - %u" , KData1);

   557         logged = EFalse;

   558         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   559 

   560         }

   561     break;

   562     

   563     case EOstTraceData:

   564         {

   565         /**

   566         Preprocessor level for all traces on. 

   567         This should not be used from traces

   568         */

   569         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   570         //const TAny* y = &KData1;

   571         

   572         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   573         OstTraceData( TRACE_FATAL, TEST_OSTTRACEDATA, "EOSTTraceData", &KData1, sizeof(KData1) );

   574         logged = EFalse;

   575         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   576 

   577         }

   578     break;

   579     

   580     case EOstTraceExt1:

   581         {

   582         /**

   583         Preprocessor level for all traces on. 

   584         This should not be used from traces

   585         */

   586         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   587         

   588         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   589         OstTraceExt1( TRACE_FATAL, TEST_OSTTRACEEXT1, "OSTTraceExt1 - %hhd", KData8 ) ;

   590         logged = EFalse;

   591         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   592 

   593         }

   594     break;

   595     

   596     case EOstTraceExt2:

   597         {

   598         /**

   599         Preprocessor level for all traces on. 

   600         This should not be used from traces

   601         */

   602         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   603         

   604         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   605         OstTraceExt2( TRACE_FATAL, TEST_OSTTRACEEXT2, "OSTTraceExt2 - %u - %u", KData1 ,KData1) ;

   606         logged = EFalse;

   607         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   608 

   609         }

   610     break;

   611     

   612     case EOstTraceExt3:

   613         {

   614         /**

   615         Preprocessor level for all traces on. 

   616         This should not be used from traces

   617         */

   618         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF          

   619         

   620         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   621         OstTraceExt3( TRACE_FATAL, TEST_OSTTRACEEXT3, "OSTTraceExt3 - %u - %u - %u", KData1 ,KData1, KData1) ;

   622         logged = EFalse;

   623         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   624 

   625         }

   626     break;

   627     

   628     case EOstTraceExt4:

   629         {

   630         /**

   631         Preprocessor level for all traces on. 

   632         This should not be used from traces

   633         */

   634         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   635         

   636         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   637         OstTraceExt4( TRACE_FATAL, TEST_OSTTRACEEXT4, "OSTTraceExt4 - %u - %u - %u - %u", KData1 ,KData1, KData1, KData1) ;

   638         logged = EFalse;

   639         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   640 

   641         }

   642     break;

   643     

   644     case EOstTraceExt5:

   645         {

   646         /**

   647         Preprocessor level for all traces on. 

   648         This should not be used from traces

   649         */

   650         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   651         

   652         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   653         OstTraceExt5( TRACE_FATAL, TEST_OSTTRACEEXT5, "OSTTraceExt5 - %u - %u - %u - %u - %u", KData1 ,KData1, KData1, KData1, KData1) ;

   654         logged = EFalse;

   655         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   656 

   657         }

   658     break;

   659     

   660     case EOstTraceFunctionEntry0:

   661         {

   662         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   663         OstTraceFunctionEntry0( TEST_OSTTraceFunctionalityEntry0 );

   664         logged = ETrue;

   665         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   666         }

   667     break;

   668     

   669     case EOstTraceFunctionEntry1:

   670         {

   671         //const TAny* y = &KData1;

   672         

   673         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   674         OstTraceFunctionEntry1( TEST_OSTTraceFunctionalityEntry1, KData1 );

   675         logged = EFalse;

   676         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   677 

   678         }

   679     break;

   680     

   681     case EOstTraceFunctionEntryExt:

   682         {

   683         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   684         OstTraceFunctionEntryExt( TEST_OSTTraceFunctionalityExt, (const TAny*)&KData1 );

   685         logged = EFalse;

   686         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   687         }

   688     break;

   689     

   690     case EOstTraceFunctionExit0:

   691         {

   692         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   693         OstTraceFunctionExit0( TEST_OstTraceFunctionExit0 );

   694         logged = EFalse;

   695         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   696         }

   697     break;

   698     

   699     case EOstTraceFunctionExit1:

   700         {

   701         //const TAny* y = &KData1;

   702         

   703         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   704         OstTraceFunctionExit1( TEST_OSTTRACEFUNCTIONEXIT1, KData1 );

   705         logged = EFalse;

   706         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   707 

   708         }

   709     break;

   710     

   711     case EOstTraceFunctionExitExt:

   712         {

   713         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   714         OstTraceFunctionExitExt( TEST_OSTTRACEFUNCTIONEXITEXT, (const TAny*)&KData1, TInt(0) );

   715         logged = EFalse;

   716         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   717 

   718         }

   719     break;

   720     

   721     case EOstTraceEventStart0:

   722         {

   723         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   724         OstTraceEventStart0( TEST_OSTTRACEEVENTSTART0, "EOstTraceEventStart0" );

   725         logged = EFalse;

   726         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   727         }

   728     break;

   729     

   730     case EOstTraceEventStart1:

   731         {

   732         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   733         OstTraceEventStart1( TEST_OSTTRACEEVENTSTART1, "EOstTraceEventStart1 - %u", KData1 ) ;

   734         logged = EFalse;

   735         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   736 

   737         }

   738     break;

   739     

   740     case EOstTraceEventStop:

   741         {

   742         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   743         OstTraceEventStop( TEST_OSTTRACEEVENTSTOP, "EOstTraceEventStop", TEST_OSTTRACEEVENTSTART0 );

   744         logged = EFalse;

   745         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   746         }

   747     break;

   748     

   749   case EOstTraceState0:

   750         {

   751         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   752         OstTraceState0( TEST_OSTTRACESTATE0, "Test State Name", "Test State Value" );

   753         logged = ETrue;

   754         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   755         }

   756     break;

   757 	

   758     case EOstTraceState1:

   759         {

   760         //const TAny* y = &KData1;

   761         

   762         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   763         OstTraceState1( TEST_OSTTRACESTATE1,  "Test State Name", "Test State Value", KData1 );

   764         logged = ETrue;

   765         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   766 

   767         }

   768     break;

   769     

   770     case EOstTraceData96:

   771         {

   772         /**

   773         Preprocessor level for all traces on. 

   774         This should not be used from traces

   775         */

   776         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   777         

   778         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   779         OstTraceData( TRACE_FATAL, TEST_OSTTRACEDATA96, "EOSTTraceData96", KBigData8, KBigSize8 );

   780         logged = EFalse;

   781         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   782 

   783         }

   784     break;

   785     

   786     case EOstTraceData1000:

   787         {

   788         /**

   789         Preprocessor level for all traces on. 

   790         This should not be used from traces

   791         */

   792         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   793         

   794         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   795         OstTraceData( TRACE_FATAL, TEST_OSTTRACEDATA1000, "EOSTTraceData1000", KHugeData8, KHugeSize8 );

   796         logged = EFalse;

   797         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   798 

   799         }

   800     break;

   801   

   802 	default:

   803 		error = KErrNotSupported;

   804 		break;

   805 	}

   806  	

   807 	//if the "trace" is in fact not an actual trace and trace not sent - this is a true result 

   808 	TBool realTrace = ETrue;

   809 	switch(aApiRunConfig.iApiId)

   810 	{

   811 	case UPTTraceTest:

   812 	case UPTKernelTraceTest:

   813 	case UPTKernelNegativeFunctionalityTest:

   814 	case UPTKernelMultipleFunctionalityTest:

   815 	case UPTBaseline:

   816 	case UPTKernelBaseline:

   817 	case UPTFooUserTime:

   818 	case UPTFooKernelTime:

   819 		realTrace = EFalse;

   820 	break;

   821 	default:

   822 	break;		

   823 	}		

   824 	

   825 	//ensure correct error values for the current test configurations are returned to the test framework

   826 	if(!logged)

   827 		{

   828 		if(error!=KErrNotSupported)

   829 			error = KErrGeneral;

   830 		}

   831 	else

   832 		error = KErrNone;

   833 

   834 	//if trace has been disabled and trace not sent - this is a true result 

   835 	#ifdef TE_UPT_TRACE_DISABLED

   836 	if(error == KErrGeneral)

   837 			error = KErrNone;

   838 	#endif

   839 

   840 	if(error == KErrGeneral && realTrace == EFalse)

   841 		error = KErrNone;

   842 

   843 

   844 	//returns KErrNone if logged, KErrNotLogged if not logged, KErrGeneral if any other problem...

   845 	return error;

   846 	}

   847 

   848 

   849 

   850 //eof