traceservices/tracefw/integ_test/ost/TEF/te_ostv2integsuite_functional/src/te_ostv2tracetestwrapper.cpp
branchRCL_3
changeset 6 5ffdb8f2067f
parent 0 08ec8eefde2f
child 23 26645d81f48d
equal deleted inserted replaced
2:6862383cf555 6:5ffdb8f2067f
    13 // Description:
    13 // Description:
    14 // Example CTestStep derived implementation
    14 // Example CTestStep derived implementation
    15 //
    15 //
    16 
    16 
    17 
    17 
    18 
       
    19 /**
    18 /**
    20  @file te_tracecontroldefaultconfig.cpp
    19  @file te_tracecontroldefaultconfig.cpp
    21  @internalTechnology
    20  @internalTechnology
    22 */
    21  */
       
    22 #ifndef OST_TRACE_COMPILER_IN_USE
       
    23 #define OST_TRACE_COMPILER_IN_USE
       
    24 #endif //OST_TRACE_COMPILER_IN_USE
       
    25 #include <opensystemtrace.h>
       
    26 
       
    27 
    23 #include "te_ostv2tracetestwrapper.h"
    28 #include "te_ostv2tracetestwrapper.h"
    24 #include "opensystemtrace_types.h"
       
    25 #include "te_ostv2tracetestwrapperTraces.h"
    29 #include "te_ostv2tracetestwrapperTraces.h"
    26 
    30 
    27 const TUint32 KTestTInt1 =  0x123;
    31 const TUint32 KTestTInt1 = 0x123;
    28 const TUint32 KTestTInt2 =  0x456;
    32 const TUint32 KTestTInt2 = 0x456;
    29 
       
    30 _LIT(KTestDuplicates, "TestDuplicates");
    33 _LIT(KTestDuplicates, "TestDuplicates");
    31 
    34 
    32 using namespace Ulogger; 
    35 _LIT(KTestOstDebugOnlyWrap, "TestOstDebugOnlyWrap");
    33 CTOstv2TraceTestWrapper::~CTOstv2TraceTestWrapper()
    36 
       
    37 //macro wrapper that works only in _DEBUG mode
       
    38 #ifndef OST_DEBUG_ONLY
       
    39 #ifdef _DEBUG
       
    40 #define OST_DEBUG_ONLY(x) x
       
    41 #else
       
    42 #define OST_DEBUG_ONLY(x)
       
    43 #endif
       
    44 #endif //ifndef OST_DEBUG_ONLY
       
    45 
       
    46 using namespace Ulogger;
    34 /**
    47 /**
    35  * Destructor
    48  * Destructor
    36  */
    49  */
    37 	{
    50 CTOstv2TraceTestWrapper::~CTOstv2TraceTestWrapper()
    38 	}
    51     {
    39 
    52     }
    40 CTOstv2TraceTestWrapper::CTOstv2TraceTestWrapper()
    53 
    41 /**
    54 /**
    42  * Constructor
    55  * Constructor
    43  */
    56  */
    44 	{
    57 CTOstv2TraceTestWrapper::CTOstv2TraceTestWrapper()
    45 	}
    58     {
       
    59     }
    46 
    60 
    47 CTOstv2TraceTestWrapper* CTOstv2TraceTestWrapper::NewLC()
    61 CTOstv2TraceTestWrapper* CTOstv2TraceTestWrapper::NewLC()
    48 	{
    62     {
    49 	CTOstv2TraceTestWrapper* self = new (ELeave)CTOstv2TraceTestWrapper();
    63     CTOstv2TraceTestWrapper* self = new (ELeave) CTOstv2TraceTestWrapper();
    50 	CleanupStack::PushL(self);
    64     CleanupStack::PushL(self);
    51 	self->ConstructL();
    65     self->ConstructL();
    52 	return self;
    66     return self;
    53 	}
    67     }
    54 
    68 
    55 CTOstv2TraceTestWrapper* CTOstv2TraceTestWrapper::NewL()
    69 CTOstv2TraceTestWrapper* CTOstv2TraceTestWrapper::NewL()
    56 	{
    70     {
    57 	CTOstv2TraceTestWrapper* self=CTOstv2TraceTestWrapper::NewLC();
    71     CTOstv2TraceTestWrapper* self = CTOstv2TraceTestWrapper::NewLC();
    58 	CleanupStack::Pop(); // self;
    72     CleanupStack::Pop(); // self;
    59 	return self;
    73     return self;
    60 	}
    74     }
    61 
    75 
    62 void CTOstv2TraceTestWrapper::ConstructL()
    76 void CTOstv2TraceTestWrapper::ConstructL()
    63 	{
    77     {
    64 	}
    78     }
    65 
    79 
    66 TAny* CTOstv2TraceTestWrapper::GetObject()
    80 TAny* CTOstv2TraceTestWrapper::GetObject()
    67 	{
    81     {
    68 	return NULL;
    82     return NULL;
    69 	}
    83     }
    70 TBool CTOstv2TraceTestWrapper::DoCommandL(	const TTEFFunction& aCommand,
    84 TBool CTOstv2TraceTestWrapper::DoCommandL(const TTEFFunction& aCommand,
    71 											const TTEFSectionName& /*aSection*/, 
    85         const TTEFSectionName& /*aSection*/, const TInt /*aAsyncErrorIndex*/)
    72 											const TInt /*aAsyncErrorIndex*/)
    86     {
    73 	{
    87 
    74 	
    88     TBool ret = ETrue;
    75 	if(aCommand == KTestDuplicates())
    89     
    76 		{
    90     if (aCommand == KTestDuplicates())
    77 		
    91         {
    78 		
    92         TestDuplicatesL();
    79 		INFO_PRINTF1(_L("CTOstv2TraceTestWrapper::DoCommandL Testing duplicates"));
    93         }
    80 		
    94     else if (aCommand == KTestOstDebugOnlyWrap())
    81 		INFO_PRINTF1(_L("Opening Ulogger connection"));
    95         {
    82 		RULogger logger;
    96         TestOstDebugOnlyWrapL();
    83 		TInt result=logger.Connect();
    97         }
    84 		INFO_PRINTF2(_L("Connection to Ulogger: %d, attempt: 1"), result);
    98     else
    85 		if (result!=KErrNone)
    99         {
    86 			 {
   100         ret = EFalse;
    87 			 INFO_PRINTF1(_L("Connection to Ulogger failed. Will try to connect max. 10 times"));
   101         }
    88 			 for (TInt i=2; i<12;i++)
   102     
    89 				 {
   103     return ret;
    90 					 User::After(1000);
   104     }
    91 					 result = logger.Connect();
   105 
    92 					 INFO_PRINTF3(_L("Connection to Ulogger: %d, attempt: %d"), result, i);
   106 
    93 					 if (result==KErrNone)
   107 TInt CTOstv2TraceTestWrapper::OpenUlogger(RULogger& aLogger)
    94 					 {
   108     {
    95 					 break;
   109 
    96 					 }
   110     INFO_PRINTF1(_L("Opening Ulogger connection"));
    97 				 }
   111     TInt result = aLogger.Connect();
    98 			 }
   112       INFO_PRINTF2(_L("Connection to Ulogger: %d, attempt: 1"), result);
    99 		
   113       if (result != KErrNone)
   100 	
   114           {
   101 		// clear the config file
   115           INFO_PRINTF1(_L("Connection to Ulogger failed. Will try to connect max. 10 times"));
   102 		CClearConfig configIni;
   116           for (TInt i = 2; i < 12; i++)
   103 		configIni.Clear(logger);
   117               {
   104 
   118               User::After(1000);
   105 		// extract the user ids from the values generated by tracecompiler
   119               result = aLogger.Connect();
   106 		const TUint8 USER_DEFINED_GID_1 = TEST_OSTTRACEWRAPPER7 >> 16;
   120               INFO_PRINTF3(_L("Connection to Ulogger: %d, attempt: %d"), result, i);
   107 		const TUint8 USER_DEFINED_GID_2 = TEST_OSTTRACEWRAPPER8 >> 16;
   121               if (result == KErrNone)
   108 		
   122                   {
   109 		// switch on primary filtering mechanism
   123                   break;
   110 		CArrayFixFlat<TUint8> *setprimfilter = new (ELeave)CArrayFixFlat<TUint8>(22);
   124                   }
   111 		setprimfilter->AppendL(KGroupId);
   125               }
   112 		setprimfilter->AppendL(TRACE_FATAL); 
   126           }
   113 		setprimfilter->AppendL(TRACE_DUMP);
   127       
   114 		setprimfilter->AppendL(TRACE_DEBUG);				
   128       if(result != KErrNone)
   115 		setprimfilter->AppendL(USER_DEFINED_GID_1);
   129           {
   116 		setprimfilter->AppendL(USER_DEFINED_GID_2);
   130           ERR_PRINTF2(_L("Failed to open Ulogger: error (%d)"), result);
   117 		
   131           }
   118 		result = logger.SetPrimaryFiltersEnabled(*setprimfilter, ETrue);
   132       
   119 				
   133       return result;
   120 		if(result != KErrNone)
   134     }
   121 			{
   135 
   122 			ERR_PRINTF2(_L("Failed to set Ulogger primary filters result(%d"), result);
   136 void CTOstv2TraceTestWrapper::TestDuplicatesL()
   123 			SetBlockResult(EFail);	
   137     {
   124 			}
   138 
   125 				
   139     INFO_PRINTF1(_L("CTOstv2TraceTestWrapper::TestDuplicates"));
   126 		// switch off secondary filtering
   140 
   127 		result = logger.SetSecondaryFilteringEnabled(EFalse);
   141     RULogger logger;
   128 		if(result != KErrNone)
   142 
   129 			{
   143     
   130 			ERR_PRINTF2(_L("Failed to set Ulogger secondary filters result(%d"), result);
   144     User::LeaveIfError(OpenUlogger(logger));
   131 			SetBlockResult(EFail);	
   145     // clear the config file
   132 			}
   146     CClearConfig configIni;
   133 		
   147     configIni.Clear(logger);
   134 		delete setprimfilter;
   148 
   135 		setprimfilter = NULL;
   149     // extract the user ids from the values generated by tracecompiler
   136 
   150     const TUint8 USER_DEFINED_GID_1 = TEST_OSTTRACEWRAPPER7 >> 16;
   137 		
   151     const TUint8 USER_DEFINED_GID_2 = TEST_OSTTRACEWRAPPER8 >> 16;
   138 		// setup output file
   152 
   139 		_LIT(KLogFilename, "C:\\logs\\duplicate_trace_test.utf");
   153     // switch on primary filtering mechanism
   140 		EmptyFile(KLogFilename);
   154     CArrayFixFlat<TUint8> *setprimfilter =
   141 		// setup ulogger to write to the file using its output plugin
   155             new (ELeave) CArrayFixFlat<TUint8> (22);
   142 		_LIT8(KTextmedia,"uloggerfileplugin");
   156     setprimfilter->AppendL(KGroupId);
   143 		TPtrC8 mediaptr(KTextmedia);
   157     setprimfilter->AppendL(TRACE_FATAL);
   144 		result=logger.ActivateOutputPlugin(mediaptr);
   158     setprimfilter->AppendL(TRACE_DUMP);
   145 		if(result == KErrNone)
   159     setprimfilter->AppendL(TRACE_DUMP);
   146 			{
   160     setprimfilter->AppendL(USER_DEFINED_GID_1);
   147 			INFO_PRINTF1(_L("file set as active output plugin ok"));
   161     setprimfilter->AppendL(USER_DEFINED_GID_2);
   148 			TPluginConfiguration pluginConfig;
   162 
   149 			_LIT(KTextsetting, "output_path");
   163     TInt result = logger.SetPrimaryFiltersEnabled(*setprimfilter, ETrue);
   150 			pluginConfig.SetKey(KTextsetting);
   164 
   151 			pluginConfig.SetValue(KLogFilename());
   165     if (result != KErrNone)
   152 			result=logger.SetPluginConfigurations(mediaptr, pluginConfig);
   166         {
   153 			if(result == KErrNone)
   167         ERR_PRINTF2(_L("Failed to set Ulogger primary filters result(%d"), result);
   154 				{
   168         SetBlockResult(EFail);
   155 				INFO_PRINTF1(_L("output plugin settings set ok"));
   169         }
   156 
   170 
   157 				result=logger.Start();
   171     // switch off secondary filtering
   158 				if(result == KErrNone)
   172     result = logger.SetSecondaryFilteringEnabled(EFalse);
   159 					{	
   173     if (result != KErrNone)
   160 					// add some traces TRACE_DEBUG & TRACE_DUMP equate to the same numeric value
   174         {
   161 					
   175         ERR_PRINTF2(_L("Failed to set Ulogger secondary filters result(%d"), result);
   162 					AddTraceHelper((TGroupId)TRACE_FATAL, (TTraceId)TEST_OSTTRACEWRAPPER1, KTestTInt1);
   176         SetBlockResult(EFail);
   163 					OstTrace1(TRACE_FATAL, 	TEST_OSTTRACEWRAPPER1, "CTOstv2TraceTestWrapper TRACE_FATAL test 1 KTestTInt1 (%d)" , KTestTInt1);
   177         }
   164 					
   178 
   165 					
   179     delete setprimfilter;
   166 					AddTraceHelper((TGroupId)TRACE_DEBUG, (TTraceId)TEST_OSTTRACEWRAPPER2, KTestTInt1);
   180     setprimfilter = NULL;
   167 					OstTrace1(TRACE_DEBUG, 	TEST_OSTTRACEWRAPPER2, "CTOstv2TraceTestWrapper TRACE_DEBUG test 1 KTestTInt1 (%d)" , KTestTInt1);
   181     // setup output file
   168 					
   182     _LIT(KLogFilename, "C:\\logs\\duplicate_trace_test.utf");
   169 					AddTraceHelper((TGroupId)TRACE_DUMP, (TTraceId)TEST_OSTTRACEWRAPPER3, KTestTInt1);
   183     EmptyFile(KLogFilename);
   170 					OstTrace1(TRACE_DUMP, 	TEST_OSTTRACEWRAPPER3, "CTOstv2TraceTestWrapper TRACE_DUMP  test 1 KTestTInt1 (%d)" , KTestTInt1);
   184     // setup ulogger to write to the file using its output plugin
   171 
   185     _LIT8(KTextmedia,"uloggerfileplugin");
   172 					AddTraceHelper((TGroupId)TRACE_FATAL, (TTraceId)TEST_OSTTRACEWRAPPER4, KTestTInt2);
   186     TPtrC8 mediaptr(KTextmedia);
   173 					OstTrace1(TRACE_FATAL, 	TEST_OSTTRACEWRAPPER4, "CTOstv2TraceTestWrapper TRACE_FATAL test 2 KTestTInt2 (%d)" , KTestTInt2);
   187     result = logger.ActivateOutputPlugin(mediaptr);
   174 					
   188     if (result == KErrNone)
   175 					AddTraceHelper((TGroupId)TRACE_DEBUG, (TTraceId)TEST_OSTTRACEWRAPPER5, KTestTInt2);
   189         {
   176 					OstTrace1(TRACE_DEBUG, 	TEST_OSTTRACEWRAPPER5, "CTOstv2TraceTestWrapper TRACE_DEBUG test 2 KTestTInt2 (%d)" , KTestTInt2);
   190         INFO_PRINTF1(_L("file set as active output plugin ok"));
   177 
   191         TPluginConfiguration pluginConfig;
   178 					AddTraceHelper((TGroupId)TRACE_DUMP, (TTraceId)TEST_OSTTRACEWRAPPER6, KTestTInt2);
   192         _LIT(KTextsetting, "output_path");
   179 					OstTrace1(TRACE_DUMP, TEST_OSTTRACEWRAPPER6, "CTOstv2TraceTestWrapper TRACE_DUMP  test 2 KTestTInt2 (%d)" , KTestTInt2);					
   193         pluginConfig.SetKey(KTextsetting);
   180 			
   194         pluginConfig.SetValue(KLogFilename());
   181 					AddTraceHelper((TGroupId)USER_DEFINED_GID_1, (TTraceId)TEST_OSTTRACEWRAPPER7, KTestTInt1);
   195         result = logger.SetPluginConfigurations(mediaptr, pluginConfig);
   182 					OstTrace1(USER_DEFINED_GID_1, TEST_OSTTRACEWRAPPER7, "CTOstv2TraceTestWrapper USER_DEFINED_GID_1  test 2 KTestTInt2 (%d)" , KTestTInt1);					
   196         if (result == KErrNone)
   183 
   197             {
   184 					AddTraceHelper((TGroupId)USER_DEFINED_GID_2, (TTraceId)TEST_OSTTRACEWRAPPER8, KTestTInt2);
   198             INFO_PRINTF1(_L("output plugin settings set ok"));
   185 					OstTrace1(USER_DEFINED_GID_2, TEST_OSTTRACEWRAPPER8, "CTOstv2TraceTestWrapper USER_DEFINED_GID_1  test 2 KTestTInt2 (%d)" , KTestTInt2);					
   199 
   186 					
   200             result = logger.Start();
   187 					result=logger.Stop();
   201             if (result == KErrNone)
   188 					
   202                 {
   189 					if(result == KErrNone)
   203                 // add some traces TRACE_DUMP & TRACE_DUMP equate to the same numeric value
   190 						{
   204 
   191 						SetBlockResult(CheckResults(KLogFilename()) == KErrNone ? EPass : EFail);
   205                 AddTraceHelper((TGroupId) TRACE_FATAL,
   192 						}					
   206                         (TTraceId) TEST_OSTTRACEWRAPPER1, KTestTInt1);
   193 					}
   207                 OstTrace1(TRACE_FATAL, TEST_OSTTRACEWRAPPER1, "CTOstv2TraceTestWrapper TRACE_FATAL test 1 KTestTInt1 (%d)" , KTestTInt1);
   194 				else
   208 
   195 					{
   209                 AddTraceHelper((TGroupId) TRACE_DUMP,
   196 					INFO_PRINTF2(_L("ulogger start returns error %d"), result);	
   210                         (TTraceId) TEST_OSTTRACEWRAPPER2, KTestTInt1);
   197 					}
   211                 OstTrace1(TRACE_DUMP, TEST_OSTTRACEWRAPPER2, "CTOstv2TraceTestWrapper TRACE_DUMP test 1 KTestTInt1 (%d)" , KTestTInt1);
   198 				}
   212 
   199 			else
   213                 AddTraceHelper((TGroupId) TRACE_DUMP,
   200 				{
   214                         (TTraceId) TEST_OSTTRACEWRAPPER3, KTestTInt1);
   201 				INFO_PRINTF2(_L("setting output plugin settings failed with err %d"), result);
   215                 OstTrace1(TRACE_DUMP, TEST_OSTTRACEWRAPPER3, "CTOstv2TraceTestWrapper TRACE_DUMP  test 1 KTestTInt1 (%d)" , KTestTInt1);
   202 				}			
   216 
   203 			}
   217                 AddTraceHelper((TGroupId) TRACE_FATAL,
   204 		else
   218                         (TTraceId) TEST_OSTTRACEWRAPPER4, KTestTInt2);
   205 			{
   219                 OstTrace1(TRACE_FATAL, TEST_OSTTRACEWRAPPER4, "CTOstv2TraceTestWrapper TRACE_FATAL test 2 KTestTInt2 (%d)" , KTestTInt2);
   206 			INFO_PRINTF2(_L("add file as output plugin failed with err %d"), result);
   220 
   207 			}
   221                 AddTraceHelper((TGroupId) TRACE_DUMP,
   208 		}
   222                         (TTraceId) TEST_OSTTRACEWRAPPER5, KTestTInt2);
   209 		return ETrue;
   223                 OstTrace1(TRACE_DUMP, TEST_OSTTRACEWRAPPER5, "CTOstv2TraceTestWrapper TRACE_DUMP test 2 KTestTInt2 (%d)" , KTestTInt2);
   210 	}
   224 
       
   225                 AddTraceHelper((TGroupId) TRACE_DUMP,
       
   226                         (TTraceId) TEST_OSTTRACEWRAPPER6, KTestTInt2);
       
   227                 OstTrace1(TRACE_DUMP, TEST_OSTTRACEWRAPPER6, "CTOstv2TraceTestWrapper TRACE_DUMP  test 2 KTestTInt2 (%d)" , KTestTInt2);
       
   228 
       
   229                 AddTraceHelper((TGroupId) USER_DEFINED_GID_1,
       
   230                         (TTraceId) TEST_OSTTRACEWRAPPER7, KTestTInt1);
       
   231                 OstTrace1(USER_DEFINED_GID_1, TEST_OSTTRACEWRAPPER7, "CTOstv2TraceTestWrapper USER_DEFINED_GID_1  test 2 KTestTInt2 (%d)" , KTestTInt1);
       
   232 
       
   233                 AddTraceHelper((TGroupId) USER_DEFINED_GID_2,
       
   234                         (TTraceId) TEST_OSTTRACEWRAPPER8, KTestTInt2);
       
   235                 OstTrace1(USER_DEFINED_GID_2, TEST_OSTTRACEWRAPPER8, "CTOstv2TraceTestWrapper USER_DEFINED_GID_1  test 2 KTestTInt2 (%d)" , KTestTInt2);
       
   236                 
       
   237                 result = logger.Stop();
       
   238 
       
   239                 if (result == KErrNone)
       
   240                     {
       
   241                     SetBlockResult(
       
   242                             CheckResults(KLogFilename()) == KErrNone
       
   243                                                                      ? EPass
       
   244                                                                         : EFail);
       
   245                     }
       
   246                 }
       
   247             else
       
   248                 {
       
   249                 INFO_PRINTF2(_L("ulogger start returns error %d"), result);
       
   250                 }
       
   251             }
       
   252         else
       
   253             {
       
   254             INFO_PRINTF2(_L("setting output plugin settings failed with err %d"), result);
       
   255             }
       
   256         }
       
   257     else
       
   258         {
       
   259         INFO_PRINTF2(_L("add file as output plugin failed with err %d"), result);
       
   260         }
       
   261     }
       
   262 
       
   263 
       
   264 void CTOstv2TraceTestWrapper::TestOstDebugOnlyWrapL()
       
   265     {
       
   266     INFO_PRINTF1(_L("CTOstv2TraceTestWrapper::TestDuplicates"));
       
   267 
       
   268     RULogger logger;
       
   269 
       
   270     
       
   271     User::LeaveIfError(OpenUlogger(logger));
       
   272     // clear the config file
       
   273     CClearConfig configIni;
       
   274     configIni.Clear(logger);
       
   275 
       
   276     // extract the user ids from the values generated by tracecompiler
       
   277     const TUint8 USER_DEFINED_GID_1w = TEST_OSTTRACEWRAPPER7w >> 16;
       
   278     const TUint8 USER_DEFINED_GID_2w = TEST_OSTTRACEWRAPPER8w >> 16;
       
   279 
       
   280     // switch on primary filtering mechanism
       
   281     CArrayFixFlat<TUint8> *setprimfilter =
       
   282             new (ELeave) CArrayFixFlat<TUint8> (22);
       
   283     setprimfilter->AppendL(KGroupId);
       
   284     setprimfilter->AppendL(TRACE_FATAL);
       
   285     setprimfilter->AppendL(TRACE_DUMP);
       
   286     setprimfilter->AppendL(TRACE_DUMP);
       
   287     setprimfilter->AppendL(USER_DEFINED_GID_1w);
       
   288     setprimfilter->AppendL(USER_DEFINED_GID_2w);
       
   289 
       
   290     TInt result = logger.SetPrimaryFiltersEnabled(*setprimfilter, ETrue);
       
   291 
       
   292     if (result != KErrNone)
       
   293         {
       
   294         ERR_PRINTF2(_L("Failed to set Ulogger primary filters result(%d"), result);
       
   295         SetBlockResult(EFail);
       
   296         }
       
   297 
       
   298     // switch off secondary filtering
       
   299     result = logger.SetSecondaryFilteringEnabled(EFalse);
       
   300     if (result != KErrNone)
       
   301         {
       
   302         ERR_PRINTF2(_L("Failed to set Ulogger secondary filters result(%d"), result);
       
   303         SetBlockResult(EFail);
       
   304         }
       
   305 
       
   306     delete setprimfilter;
       
   307     setprimfilter = NULL;
       
   308     // setup output file
       
   309     _LIT(KLogFilename, "C:\\logs\\duplicate_trace_test.utf");
       
   310     EmptyFile(KLogFilename);
       
   311     // setup ulogger to write to the file using its output plugin
       
   312     _LIT8(KTextmedia,"uloggerfileplugin");
       
   313     TPtrC8 mediaptr(KTextmedia);
       
   314     result = logger.ActivateOutputPlugin(mediaptr);
       
   315     if (result == KErrNone)
       
   316         {
       
   317         INFO_PRINTF1(_L("file set as active output plugin ok"));
       
   318         TPluginConfiguration pluginConfig;
       
   319         _LIT(KTextsetting, "output_path");
       
   320         pluginConfig.SetKey(KTextsetting);
       
   321         pluginConfig.SetValue(KLogFilename());
       
   322         result = logger.SetPluginConfigurations(mediaptr, pluginConfig);
       
   323         if (result == KErrNone)
       
   324             {
       
   325             INFO_PRINTF1(_L("output plugin settings set ok"));
       
   326 
       
   327             result = logger.Start();
       
   328             if (result == KErrNone)
       
   329                 {
       
   330                 // now try the same traces again but with the OST_DEBUG_ONLY wrapper
       
   331                 OST_DEBUG_ONLY(AddTraceHelper((TGroupId) TRACE_FATAL,
       
   332                         (TTraceId) TEST_OSTTRACEWRAPPER1w, KTestTInt1));
       
   333                 OST_DEBUG_ONLY(OstTrace1(TRACE_FATAL, TEST_OSTTRACEWRAPPER1w, "CTOstv2TraceTestWrapper TRACE_FATAL test 1 KTestTInt1 (%d)" , KTestTInt1));
       
   334 
       
   335                 OST_DEBUG_ONLY(AddTraceHelper((TGroupId) TRACE_DUMP,
       
   336                         (TTraceId) TEST_OSTTRACEWRAPPER2w, KTestTInt1));
       
   337                 OST_DEBUG_ONLY(OstTrace1(TRACE_DUMP, TEST_OSTTRACEWRAPPER2w, "CTOstv2TraceTestWrapper TRACE_DUMP test 1 KTestTInt1 (%d)" , KTestTInt1));
       
   338 
       
   339                 OST_DEBUG_ONLY(AddTraceHelper((TGroupId) TRACE_DUMP,
       
   340                         (TTraceId) TEST_OSTTRACEWRAPPER3w, KTestTInt1));
       
   341                 OST_DEBUG_ONLY(OstTrace1(TRACE_DUMP, TEST_OSTTRACEWRAPPER3w, "CTOstv2TraceTestWrapper TRACE_DUMP  test 1 KTestTInt1 (%d)" , KTestTInt1));
       
   342 
       
   343                 OST_DEBUG_ONLY(AddTraceHelper((TGroupId) TRACE_FATAL,
       
   344                         (TTraceId) TEST_OSTTRACEWRAPPER4w, KTestTInt2));
       
   345                 OST_DEBUG_ONLY(OstTrace1(TRACE_FATAL, TEST_OSTTRACEWRAPPER4w, "CTOstv2TraceTestWrapper TRACE_FATAL test 2 KTestTInt2 (%d)" , KTestTInt2));
       
   346 
       
   347                 OST_DEBUG_ONLY(AddTraceHelper((TGroupId) TRACE_DUMP,
       
   348                         (TTraceId) TEST_OSTTRACEWRAPPER5w, KTestTInt2));
       
   349                 OST_DEBUG_ONLY(OstTrace1(TRACE_DUMP, TEST_OSTTRACEWRAPPER5w, "CTOstv2TraceTestWrapper TRACE_DUMP test 2 KTestTInt2 (%d)" , KTestTInt2));
       
   350 
       
   351                 OST_DEBUG_ONLY(AddTraceHelper((TGroupId) TRACE_DUMP,
       
   352                         (TTraceId) TEST_OSTTRACEWRAPPER6w, KTestTInt2));
       
   353                 OST_DEBUG_ONLY(OstTrace1(TRACE_DUMP, TEST_OSTTRACEWRAPPER6w, "CTOstv2TraceTestWrapper TRACE_DUMP  test 2 KTestTInt2 (%d)" , KTestTInt2));
       
   354 
       
   355                 OST_DEBUG_ONLY(AddTraceHelper((TGroupId) USER_DEFINED_GID_1w,
       
   356                         (TTraceId) TEST_OSTTRACEWRAPPER7w, KTestTInt1));
       
   357                 OST_DEBUG_ONLY(OstTrace1(USER_DEFINED_GID_1, TEST_OSTTRACEWRAPPER7w, "CTOstv2TraceTestWrapper USER_DEFINED_GID_1  test 2 KTestTInt2 (%d)" , KTestTInt1));
       
   358 
       
   359                 OST_DEBUG_ONLY(AddTraceHelper((TGroupId) USER_DEFINED_GID_2w,
       
   360                         (TTraceId) TEST_OSTTRACEWRAPPER8w, KTestTInt2));
       
   361                 OST_DEBUG_ONLY(OstTrace1(USER_DEFINED_GID_2, TEST_OSTTRACEWRAPPER8w, "CTOstv2TraceTestWrapper USER_DEFINED_GID_1  test 2 KTestTInt2 (%d)" , KTestTInt2));
       
   362 
       
   363                                 
       
   364                 result = logger.Stop();
       
   365 
       
   366                 if (result == KErrNone)
       
   367                     {
       
   368                     SetBlockResult(
       
   369                             CheckResults(KLogFilename()) == KErrNone
       
   370                                                                      ? EPass
       
   371                                                                         : EFail);
       
   372                     }
       
   373                 }
       
   374             else
       
   375                 {
       
   376                 INFO_PRINTF2(_L("ulogger start returns error %d"), result);
       
   377                 }
       
   378             }
       
   379         else
       
   380             {
       
   381             INFO_PRINTF2(_L("setting output plugin settings failed with err %d"), result);
       
   382             }
       
   383         }
       
   384     else
       
   385         {
       
   386         INFO_PRINTF2(_L("add file as output plugin failed with err %d"), result);
       
   387         }
       
   388     }
   211 
   389 
   212 
   390 
   213 TInt CTOstv2TraceTestWrapper::CheckResults(const TDesC& aLogFilename)
   391 TInt CTOstv2TraceTestWrapper::CheckResults(const TDesC& aLogFilename)
   214 	{
   392     {
   215 	// read the logged traces from the log file	
   393     // read the logged traces from the log file	
   216 	TInt  err = ReadFromLogFile(aLogFilename);
   394     TInt err = ReadFromLogFile(aLogFilename);
   217 	if(err == KErrNone)
   395     if (err == KErrNone)
   218 		{
   396         {
   219 		err = CompareTraces();
   397         err = CompareTraces();
   220 		if(err == KErrNone)
   398         if (err == KErrNone)
   221 			{
   399             {
   222 			
   400 
   223 			}
   401             }
   224 		else{
   402         else
   225 			ERR_PRINTF2(_L("CompareTraces returned err (%d)"), err);
   403             {
   226 			}
   404             ERR_PRINTF2(_L("CompareTraces returned err (%d)"), err);
   227 		}
   405             }
   228 	else
   406         }
   229 		{
   407     else
   230 		ERR_PRINTF2(_L("ReadFromLogFile returned err (%d)"), err);
   408         {
   231 		}
   409         ERR_PRINTF2(_L("ReadFromLogFile returned err (%d)"), err);
   232 	
   410         }
   233 	return err;
   411 
   234 	}
   412     return err;
   235 
   413     }
   236 
   414 
   237 
   415 void CTOstv2TraceTestWrapper::CTOstv2TraceTestWrapper::AddTraceHelper(
   238 void CTOstv2TraceTestWrapper::CTOstv2TraceTestWrapper::AddTraceHelper(const TGroupId aGroupId, const TTraceId aTraceId, TUint32 aValue)
   416         const TGroupId aGroupId, const TTraceId aTraceId, TUint32 aValue)
   239 	{	
   417     {
   240 	if( CreateTraceObject(KOstTraceComponentID, aGroupId, EAddThreadIdentification , ENoProgramCounter, iSentTraces))
   418     if (CreateTraceObject(KOstTraceComponentID, aGroupId,
   241 		{
   419             EAddThreadIdentification, ENoProgramCounter, iSentTraces))
   242 		TTraceConfigs& config = *iSentTraces[iSentTraces.Count()-1];
   420         {
   243 		TTraceConfigsOperator::SetData(config, aValue );					
   421         TTraceConfigs& config = *iSentTraces[iSentTraces.Count() - 1];
   244 		TTraceConfigsOperator::SetHeader(config, aGroupId, KOstTraceComponentID, EAddThreadIdentification , ENoProgramCounter, aTraceId);
   422         TTraceConfigsOperator::SetData(config, aValue);
   245 		}
   423         TTraceConfigsOperator::SetHeader(config, aGroupId,
   246 	else
   424                 KOstTraceComponentID, EAddThreadIdentification,
   247 		{
   425                 ENoProgramCounter, aTraceId);
   248 		ERR_PRINTF2(_L("CreateTraceObject failed with for traceid (%d)"),  aTraceId);
   426         }
   249 		SetBlockResult(EFail);
   427     else
   250 		}	
   428         {
   251 	}
   429         ERR_PRINTF2(_L("CreateTraceObject failed with for traceid (%d)"), aTraceId);
       
   430         SetBlockResult(EFail);
       
   431         }
       
   432     }
       
   433 
       
   434 
       
   435 
       
   436