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 // Example CTestStep derived implementation

    15 //

    16 

    17 

    18 

    19 /**

    20  @file te_tracecollectorclient.cpp

    21  @internalTechnology

    22 */

    23 #include "te_tracecollectorclient.h"

    24 #include "te_ostv2integsuite_defs.h"

    25 

    26 

    27 using namespace Ulogger; //CA:added so can use old ulogger api

    28 /*******************************************************************************/

    29 /*********************************Primary Filter Test***************************/

    30 /*******************************************************************************/

    31 _LIT(KTextsetting, "output_path");

    32 

    33 CTCMGroupIDFilteringWrapper::~CTCMGroupIDFilteringWrapper()

    34 /**

    35  * Destructor

    36  */

    37 	{

    38 	}

    39 

    40 CTCMGroupIDFilteringWrapper::CTCMGroupIDFilteringWrapper()

    41 /**

    42  * Constructor

    43  */

    44 	{

    45 	}

    46 

    47 

    48 CTCMGroupIDFilteringWrapper* CTCMGroupIDFilteringWrapper::NewLC()

    49 	{

    50 	CTCMGroupIDFilteringWrapper* self = new (ELeave)CTCMGroupIDFilteringWrapper();

    51 	CleanupStack::PushL(self);

    52 	self->ConstructL();

    53 	return self;

    54 	}

    55 

    56 CTCMGroupIDFilteringWrapper* CTCMGroupIDFilteringWrapper::NewL()

    57 	{

    58 	CTCMGroupIDFilteringWrapper* self=CTCMGroupIDFilteringWrapper::NewLC();

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

    60 	return self;

    61 	}

    62 

    63 void CTCMGroupIDFilteringWrapper::ConstructL()

    64 	{

    65 	}

    66 

    67 TAny* CTCMGroupIDFilteringWrapper::GetObject()

    68 	{

    69 	return NULL;

    70 	}

    71 TBool CTCMGroupIDFilteringWrapper::DoCommandL(	const TTEFFunction& /*aCommand*/,

    72 					const TTEFSectionName& /*aSection*/, 

    73 					const TInt /*aAsyncErrorIndex*/)

    74 	{

    75 	  if (BlockResult()==EPass)

    76 		{

    77 		//  ************** Delete the Block, the block start ****************

    78 

    79 		TInt result=0;

    80 		RULogger logger;

    81 		CArrayFixFlat<TUint8> *setfilter = new (ELeave)CArrayFixFlat<TUint8>(1);

    82 		setfilter->AppendL(KGroupId);

    83 		CArrayFixFlat<TUint8> *getfilter = new (ELeave)CArrayFixFlat<TUint8>(1);

    84 		CArrayFixFlat<TUint8> *removefilter = new (ELeave)CArrayFixFlat<TUint8>(1);

    85 		removefilter->AppendL(setfilter->At(0));

    86 

    87 		/**************First set primary filter*************/

    88 

    89 		result = logger.Connect();

    90 		INFO_PRINTF2(_L("Connection to Ulogger: %d, attempt: 1"), result);

    91 		 	if (result!=KErrNone)

    92  		    {

    93             INFO_PRINTF1(_L("Connection to Ulogger failed. Will try to connect max. 10 times"));

    94             for (TInt i=2; i<12;i++)

    95                {

    96                User::After(1000);

    97                result = logger.Connect();

    98                INFO_PRINTF3(_L("Connection to Ulogger: %d, attempt: %d"), result, i);

    99                if (result==KErrNone)

   100                     {

   101                     break;

   102                     }

   103                }

   104  		    }

   105 		CClearConfig configIni;

   106 		configIni.Clear(logger);

   107 		INFO_PRINTF2(_L("connect err %d"), result);

   108 		result=logger.SetPrimaryFiltersEnabled(*setfilter,ETrue);//C.A. previously:result=logger.EnableClassifications(*setfilter);

   109 

   110 		if(result==KErrNone)

   111 			INFO_PRINTF2(_L("Primary filter has been set with single filter, %d, check log"), setfilter->At(0));

   112 		else

   113 			INFO_PRINTF2(_L("Primary filter was not set, error returned, %d"), result);

   114 

   115 		/**************Now get the GroupId filter set above************/

   116 

   117 		logger.GetPrimaryFiltersEnabled(*getfilter);//C.A. previously:logger.GetEnabledClassifications(*getfilter);

   118 		INFO_PRINTF1(_L("Get Primary filter returns the following filters"));

   119 		for(TInt i=0;i!=getfilter->Count();i++)

   120 		{

   121 			INFO_PRINTF2(_L("get filter returns %d "),getfilter->At(i));

   122 		}

   123 		if(getfilter->At(0)==setfilter->At(0))

   124 		{

   125 			result=0;

   126 			INFO_PRINTF1(_L("Get primary filter successful"));

   127 		}

   128 		else

   129 		{

   130 			INFO_PRINTF1(_L("Get primary filter failed"));

   131 			result=1;

   132 		}

   133 		getfilter->Reset();

   134 		/*****************Now remove the above set filter***************/

   135 

   136 		if(result==0)

   137 		{

   138 			result=logger.SetPrimaryFiltersEnabled(*removefilter,EFalse);//C.A. previously:result=logger.DisableClassifications(*removefilter);

   139 			INFO_PRINTF2(_L("Remove GroupId filters single filter, 0 if succesful: %d"), result);

   140 			logger.GetPrimaryFiltersEnabled(*getfilter);//C.A. previously:logger.GetEnabledClassifications(*getfilter);

   141 

   142 			if(getfilter->Count()==0&&result==KErrNone)

   143 			{

   144 				INFO_PRINTF1(_L("Remove primary filter successful"));

   145 				result=0;

   146 			}

   147 			else

   148 			{

   149 				if(result!=KErrNone)

   150 					INFO_PRINTF1(_L("Remove primary filter failed, as filter has not been set in the config file"));

   151 				else

   152 					INFO_PRINTF1(_L("Remove primary filter failed, as able to pass same filter option to RemovePrimaryFilter"));

   153 				result=1;

   154 			}

   155 		}

   156 		getfilter->Reset();

   157 

   158 		/****Now if the above steps have passed proceed to testing multiple filters***/

   159 

   160 		if(result==1)

   161 			SetBlockResult(EFail);

   162 		else

   163 		{

   164 			CArrayFixFlat<TUint8> *setfilters = new (ELeave)CArrayFixFlat<TUint8>(10);

   165 			CArrayFixFlat<TUint8> *getfilters = new (ELeave)CArrayFixFlat<TUint8>(10);

   166 			for(TInt i=0;i!=KMaxNumberOfGroupIds;i++)

   167 			{

   168 				setfilters->AppendL((TUint8)(i));

   169 			}

   170 

   171 			/**************First set  multiple primary filter*************/

   172 

   173 			result=logger.SetPrimaryFiltersEnabled(*setfilters,ETrue);//C.A. previously:result=logger.EnableClassifications(*setfilters);

   174 			if(result==KErrNone)

   175 				INFO_PRINTF1(_L("Primary filter has been set with multiple filters,from 0 to 255"));

   176 			else

   177 				INFO_PRINTF2(_L("Multiple primary filters have not been set succesfully, error code %d"), result);

   178 

   179 			/**************Now get the GroupId filter set above************/

   180 			result = logger.Connect();

   181 

   182 			INFO_PRINTF2(_L("Connection to Ulogger: %d, attempt: 1"), result);

   183 		 	if (result!=KErrNone)

   184 		 	    {

   185      			INFO_PRINTF1(_L("Connection to Ulogger failed. Will try to connect max. 10 times"));

   186             	for (TInt i=2; i<12;i++)

   187                    {

   188                    User::After(1000);

   189                    result = logger.Connect();

   190                    INFO_PRINTF3(_L("Connection to Ulogger: %d, attempt: %d"), result, i);

   191                    if (result==KErrNone)

   192 						{

   193                        	break;

   194 						}

   195                    }

   196 		 	    }

   197 

   198 			logger.GetPrimaryFiltersEnabled(*getfilters);//C.A. previously:logger.GetEnabledClassifications(*getfilters);

   199 			if(getfilters->Count()==setfilters->Count())

   200 				INFO_PRINTF1(_L("setfilter and getfilter have the same count"));

   201 			else

   202 			{

   203 				INFO_PRINTF1(_L("setfilter and getfilter have different counts"));

   204 				INFO_PRINTF2(_L("setfilter has %d"), setfilters->Count());

   205 				INFO_PRINTF2(_L("getfilter has %d"), getfilters->Count());

   206 				result=1;

   207 			}

   208 			if(result==0)

   209 			{

   210 				for(TInt i=0;i!=getfilters->Count() && result==0;i++)

   211 				{

   212 					for(TInt j=0;j!=setfilters->Count() && result!=0;j++)

   213 					{

   214 						if(getfilters->At(i)==setfilters->At(j))

   215 							result=0;

   216 						else

   217 							result=1;

   218 					}

   219 				}

   220 			}

   221 			if(result==0)

   222 				INFO_PRINTF1(_L("Get multiple primary filters successful"));

   223 			else

   224 				INFO_PRINTF1(_L("Get multiple primary filters failed"));

   225 			INFO_PRINTF1(_L("Get Primary filters returns multiple filters"));

   226 		//	for(int i=0;i!=KMaxNumberOfGroupIds;i++)

   227 		//		INFO_PRINTF2(_L(" %d"), getfilters->operator[](i));	//uncomment to verify get filters test correct

   228 			getfilters->Reset();

   229 

   230 			/*****************Given this is successful, now remove the above set filter***************/

   231 

   232 			if(result==0)

   233 			{

   234 				logger.Connect();

   235 				logger.SetPrimaryFiltersEnabled(*removefilter,EFalse);//C.A. previously:logger.DisableClassifications(*removefilter);

   236 			//	getfilter.Append(removefilter);

   237 			//	logger.EnableClassifications(getfilter);//uncomment these to negative test the test suite

   238 				logger.GetPrimaryFiltersEnabled(*getfilters);//C.A. previously:logger.GetEnabledClassifications(*getfilters);

   239 				for(TInt i=0; i!=getfilters->Count() && result==0;i++)

   240 				{

   241 					if(getfilters->At(i)==removefilter->At(0))

   242 					{

   243 						INFO_PRINTF1(_L("Remove primary filter in multiple test failed"));

   244 						result=1;

   245 					}

   246 					else

   247 						result=0;

   248 				}

   249 				if(result==0)

   250 					INFO_PRINTF1(_L("Remove primary filter in multiple test successful"));

   251 				else

   252 					INFO_PRINTF1(_L("Remove primary filter in multiple test failed"));

   253 			}

   254 			INFO_PRINTF1(_L("Now, given that the above tests have passed, negative test the primary filter options"));

   255 			INFO_PRINTF1(_L("First reset the removed filter, then proceed"));

   256 			setfilter->At(0)=removefilter->At(0);

   257 			logger.SetPrimaryFiltersEnabled(*setfilter,ETrue);//C.A. previously:logger.EnableClassifications(*setfilter);

   258 			if(result==0)

   259 			{

   260 				INFO_PRINTF1(_L("Removed filter has been reset"));

   261 

   262 				/************Now try to set a primary filter value greater than that allowed***/

   263 

   264 				setfilter->At(0)=((TGroupId)(KMaxNumberOfGroupIds));

   265 				INFO_PRINTF2(_L("setfilter is %d"), setfilter->At(0));

   266 				TInt r=logger.SetPrimaryFiltersEnabled(*setfilter,ETrue);//C.A. previously:TInt r=logger.EnableClassifications(*setfilter);

   267 				if((r==KErrNone)&&(setfilter->At(0)==KMaxNumberOfGroupIds-256))

   268 				{

   269 					INFO_PRINTF3(_L("Primary filter has been set with filter %d,corresponding to the passed value %d, this is allowed as duplicate! Passed"), setfilter->At(0),KMaxNumberOfGroupIds );

   270 					result=0;

   271 				}

   272 				else if((r==KErrNone)&&(setfilter->At(0)!=KMaxNumberOfGroupIds-256))

   273 				{

   274 					INFO_PRINTF3(_L("Primary filter has been set with filter %d,corresponding to the passed value %d, this is not allowed as not duplicate! Failed"), setfilter->At(0),KMaxNumberOfGroupIds );

   275 					result=1;

   276 				}

   277 				else

   278 				{

   279 					INFO_PRINTF3(_L("Primary filter has not been set with filter %d, corresponding to the passed value %d. Passed"), setfilter->At(0), KMaxNumberOfGroupIds);

   280 					result=0;

   281 				}

   282 

   283 				/************Now try to set more primary filter values greater than available***/

   284 

   285 				{

   286 					INFO_PRINTF1(_L("Now try to set more filter than available using a duplicate"));

   287 					if(result==0)

   288 					{

   289 						setfilter->At(0)=((TGroupId)(KMaxNumberOfGroupIds-1));

   290 						result=logger.SetPrimaryFiltersEnabled(*setfilter,ETrue);//C.A. previously:result=logger.EnableClassifications(*setfilter);

   291 						if((result==KErrNone)&&(setfilter->At(0)!=KMaxNumberOfGroupIds-1))

   292 						{

   293 							INFO_PRINTF1(_L("More primary filters than available can be set. Failed"));

   294 							result=1;

   295 						}

   296 						else

   297 						{

   298 							INFO_PRINTF1(_L("More primary filters than available cannot be set OR the filter being set is a duplicate. Passed"));

   299 							result=0;

   300 						}

   301 					}

   302 				}

   303 			}

   304 			if(result==1)

   305 				SetBlockResult(EFail);

   306 			else

   307 				SetBlockResult(EPass);

   308 			if(setfilters)

   309 			{

   310 				delete setfilters;

   311 				setfilters=NULL;

   312 			}

   313 			setfilter->Reset();

   314 			if(getfilters)

   315 			{

   316 				delete getfilters;

   317 				getfilters=NULL;

   318 			}

   319 		}

   320 

   321 		//  **************   Block end ****************

   322 

   323 		configIni.Clear(logger);

   324 		logger.Close();

   325 		if(setfilter)

   326 			delete setfilter;

   327 		if(getfilter)

   328 			delete getfilter;

   329 		}

   330 	  return ETrue;

   331 	}

   332 

   333 

   334 

   335 /*******************************************************************************/

   336 /*********************************Secondary Filter Test***************************/

   337 /*******************************************************************************/

   338 

   339 

   340 CTCMComponentIDFilteringWrapper::~CTCMComponentIDFilteringWrapper()

   341 /**

   342  * Destructor

   343  */

   344 	{

   345 	}

   346 

   347 CTCMComponentIDFilteringWrapper::CTCMComponentIDFilteringWrapper()

   348 /**

   349  * Constructor

   350  */

   351 	{

   352 	}

   353 

   354 

   355 CTCMComponentIDFilteringWrapper* CTCMComponentIDFilteringWrapper::NewLC()

   356 	{

   357 	CTCMComponentIDFilteringWrapper* self = new (ELeave)CTCMComponentIDFilteringWrapper();

   358 	CleanupStack::PushL(self);

   359 	self->ConstructL();

   360 	return self;

   361 	}

   362 

   363 CTCMComponentIDFilteringWrapper* CTCMComponentIDFilteringWrapper::NewL()

   364 	{

   365 	CTCMComponentIDFilteringWrapper* self=CTCMComponentIDFilteringWrapper::NewLC();

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

   367 	return self;

   368 	}

   369 

   370 void CTCMComponentIDFilteringWrapper::ConstructL()

   371 	{

   372 	}

   373 

   374 TAny* CTCMComponentIDFilteringWrapper::GetObject()

   375 	{

   376 	return NULL;

   377 	}

   378 

   379 TBool CTCMComponentIDFilteringWrapper::DoCommandL(	const TTEFFunction& /*aCommand*/,

   380 					const TTEFSectionName& /*aSection*/, 

   381 					const TInt /*aAsyncErrorIndex*/)

   382 	{

   383 	  if (BlockResult()==EPass)

   384 		{

   385 		//  ************** Delete the Block, the block start ****************

   386             INFO_PRINTF1(_L("do stepL"));

   387 			TInt result=0;

   388 			RULogger logger;

   389 			RArray<TUint32> setfilter;

   390 			setfilter.Append((TUint32) KComponentId);

   391 			RArray<TUint32> dupfilter;

   392 			RArray<TUint32> getfilter;

   393 			RArray<TUint32> removefilter;

   394 			removefilter.Append(setfilter[0]);

   395 		//	removefilter=32; //uncomment to negative test the remove filter option

   396 

   397 			/**************First set Secondary filter*************/

   398 

   399 			result = logger.Connect();

   400 			INFO_PRINTF2(_L("Connection to Ulogger: %d, attempt: 1"), result);

   401 		 	if (result!=KErrNone)

   402 		 	    {

   403      			INFO_PRINTF1(_L("Connection to Ulogger failed. Will try to connect max. 10 times"));

   404             	for (TInt i=2; i<12;i++)

   405                    {

   406                    User::After(1000);

   407                    result = logger.Connect();

   408                    INFO_PRINTF3(_L("Connection to Ulogger: %d, attempt: %d"), result, i);

   409                    if (result==KErrNone)

   410 						{

   411                        	break;

   412 						}

   413                    }

   414 		 	    }

   415 

   416 			CClearConfig configIni;

   417 			configIni.Clear(logger);

   418 			result = logger.SetSecondaryFiltersEnabled(setfilter,ETrue);//C.A. previously:result = logger.EnableModuleUids(setfilter);

   419 			INFO_PRINTF2(_L("Secondary filter has been set with single filter, %d, check log"), setfilter[0]);

   420 			INFO_PRINTF2(_L("code: %d"), result);

   421 

   422 

   423 			/**************Now get the Secondary filter set above************/

   424 

   425 			result = logger.GetSecondaryFiltersEnabled(getfilter);//C.A. previously:result = logger.GetEnabledModuleUids(getfilter);

   426 			INFO_PRINTF1(_L("Get Secondary filter returns the following filters"));

   427 			INFO_PRINTF2(_L("code: %d"), result);

   428 			for(TInt i=0;i!=getfilter.Count();i++)

   429 			{

   430 				INFO_PRINTF2(_L("%d "),getfilter[i]);

   431 			}

   432 			if(getfilter[0]==setfilter[0])

   433 			{

   434 				result=0;

   435 				INFO_PRINTF1(_L("Get Secondary filter successful"));

   436 			}

   437 			else

   438 			{

   439 				INFO_PRINTF1(_L("Get Secondary filter failed"));

   440 				result=1;

   441 			}

   442 			for(TInt i=0;i!=getfilter.Count();)//i++)

   443 			{

   444 				getfilter.Remove(0);

   445 			}

   446 

   447 			/*****************Now remove the above set filter***************/

   448 

   449 			if(result==0)

   450 			{

   451 				result=logger.SetSecondaryFiltersEnabled(removefilter,EFalse);//C.A. previously:result=logger.DisableModuleUids(removefilter);

   452 				INFO_PRINTF2(_L("Remove Module Uid filters single filter, 0 if succesful, -1 if failed: %d"), result);//logger.RemoveSingleSecondary);

   453 				logger.GetSecondaryFiltersEnabled(getfilter);//C.A. previously:logger.GetEnabledModuleUids(getfilter);

   454 				if(getfilter.Count()==0)

   455 				{

   456 					INFO_PRINTF1(_L("Remove ModuleUid filter successful"));

   457 					result=0;

   458 				}

   459 				else

   460 				{

   461 					if(result!=0)

   462 						INFO_PRINTF1(_L("Remove ModuleUid filter failed, as filter has not been set in the config file"));

   463 					else

   464 						INFO_PRINTF1(_L("Remove ModuleUid filter failed, as able to pass same filter option to RemoveSecondaryFilter"));

   465 					result=1;

   466 				}

   467 			}

   468 

   469 			/****Now if the above steps have passed proceed to testing multiple filters***/

   470 

   471 			if(result==1)

   472 				SetBlockResult(EFail);

   473 			else

   474 			{

   475 				RArray<TUint32> setfilters;

   476 				RArray<TUint32> getfilters;

   477 				INFO_PRINTF2(_L("maxsecondary %d"),KMaxNumberOfComponentIds);

   478 				for(TInt i=0;i<KMaxNumberOfComponentIds;i++)

   479 				{

   480 					setfilters.Append((TUint32)(i));

   481 				}

   482 				INFO_PRINTF1(_L("initialising values for multiple secondary filters ok, now set the filters etc"));

   483 

   484 				/**************First set  multiple Secondary filter*************/

   485 

   486 				result=logger.SetSecondaryFiltersEnabled(setfilters,ETrue);//C.A. previously:result=logger.EnableModuleUids(setfilters);

   487 				if(result==KErrNone)

   488 				INFO_PRINTF2(_L("Secondary filter has been set with multiple filters,from 0 to %d"), KMaxNumberOfComponentIds);

   489 				else

   490 					INFO_PRINTF2(_L("Multiple secondary filters have not been set succesfully, error code %d"), result);

   491 

   492 				/**************Now get the Secondary filter set above************/

   493 

   494 				INFO_PRINTF2(_L("before get, getfilter has %d"), getfilters.Count());

   495 				logger.GetSecondaryFiltersEnabled(getfilters);//C.A. previously:logger.GetEnabledModuleUids(getfilters);

   496 				if(getfilters.Count()==setfilters.Count())

   497 				{

   498 					INFO_PRINTF1(_L("setfilter and getfilter have the same count"));

   499 					INFO_PRINTF2(_L("setfilter has %d"), setfilters.Count());

   500 					INFO_PRINTF2(_L("getfilter has %d"), getfilters.Count());

   501 				}

   502 				else

   503 				{

   504 					INFO_PRINTF1(_L("setfilter and getfilter have different counts"));

   505 					result=1;

   506 						INFO_PRINTF2(_L("setfilter has %d"), setfilters.Count());

   507 						INFO_PRINTF2(_L("getfilter has %d"), getfilters.Count());

   508 				}

   509 				for(TInt i=0;i!=getfilters.Count() && result==0;i++)

   510 				{

   511 					for(TInt j=0;j!=getfilters.Count() && result!=0;j++)

   512 					{

   513 						if(getfilters[i]==setfilters[j])

   514 							result=0;

   515 						else

   516 							result=1;

   517 					}

   518 				}

   519 				if(result==0)

   520 					INFO_PRINTF1(_L("Get multiple Secondary filters successful"));

   521 				else

   522 					INFO_PRINTF1(_L("Get multiple Secondary filters failed"));

   523 				INFO_PRINTF1(_L("Get Secondary filters returns multiple filters"));

   524 			//	for(int i=0;i!=getfilters.Count();i++)//KMaxNumberOfComponentIds;i++)

   525 			//		INFO_PRINTF2(_L(" %d"), getfilters[i]);	//uncomment to verify get filters test correct - WARNING-loadsa data if use true maximum for secondary filters-will break TEF!!

   526 				for(TInt i=0;i<getfilters.Count();)//i++)

   527 				{

   528 					getfilters.Remove(0);

   529 				}

   530 

   531 				/*****************Given this is successful, now remove the above set filter***************/

   532 

   533 				if(result==0)

   534 				{

   535 					logger.SetSecondaryFiltersEnabled(removefilter,EFalse);//C.A. previously:logger.DisableModuleUids(removefilter);

   536 				//	getfilter.Append(removefilter);

   537 				//	logger.EnableModuleUids(getfilter);//uncomment these to negative test the test suite

   538 					logger.GetSecondaryFiltersEnabled(getfilters);//C.A. previously:logger.GetEnabledModuleUids(getfilters);

   539 					for(TInt i=0; i!=getfilters.Count() && result==0;i++)

   540 					{

   541 						if(getfilters[i]==removefilter[0])

   542 						{

   543 							INFO_PRINTF1(_L("Remove Secondary filter in multiple test failed"));

   544 							result=1;

   545 						}

   546 						else

   547 							result=0;

   548 					}

   549 					if(result==0)

   550 						INFO_PRINTF1(_L("Remove Secondary filter in multiple test successful"));

   551 					else

   552 					INFO_PRINTF1(_L("Remove Secondary filter in multiple test failed"));

   553 				}

   554 				INFO_PRINTF1(_L("Now, given that the above tests have passed, negative test the secondary filter options"));

   555 				INFO_PRINTF1(_L("First reset the removed filter, then proceed"));

   556 				setfilter[0]=removefilter[0];

   557 				logger.SetSecondaryFiltersEnabled(setfilter,ETrue);//C.A. previously:logger.EnableModuleUids(setfilter);

   558 				if(result==0)

   559 				{

   560 					INFO_PRINTF1(_L("Removed filter has been reset"));

   561 

   562 					/************Now try to set a secondary filter value greater than that allowed***/

   563 

   564 					setfilter[0]=((TComponentId)(KMaxNumberOfComponentIds-1));

   565 					INFO_PRINTF2(_L("setfilter is %d"), setfilter[0]);

   566 					TInt r= logger.SetSecondaryFiltersEnabled(setfilter,ETrue);//C.A. previously:TInt r= logger.EnableModuleUids(setfilter);

   567 					if((r==KErrNone)&&(setfilter[0]==KMaxNumberOfComponentIds-1))

   568 					{

   569 						INFO_PRINTF3(_L("Secondary filter has been set with filter %d,corresponding to the passed value %d, this is allowed as is duplicate. Passed"), setfilter[0],KMaxNumberOfComponentIds-1 );

   570 						result=0;

   571 					}

   572 					if((r==KErrNone)&&(setfilter[0]!=KMaxNumberOfComponentIds-1))

   573 					{

   574 						INFO_PRINTF3(_L("Secondary filter has been set with filter %d,corresponding to the passed value %d, this is not allowed. Failed"), setfilter[0],KMaxNumberOfComponentIds-1 );

   575 						result=1;

   576 					}

   577 					else

   578 

   579 					{

   580 						INFO_PRINTF3(_L("Secondary filter has not been set with filter %d, corresponding to the passed value %d , this is as expected as otherwise duplicate. Passed"), setfilter[0], KMaxNumberOfComponentIds-1);

   581 						result=0;

   582 					}

   583 					/************Now try to set more secodndary filter values greater than available***/

   584 

   585 					INFO_PRINTF1(_L("Now try to set more filter than available"));

   586 					if(result==0)

   587 					{

   588 						setfilter[0]=((TComponentId)(KMaxNumberOfComponentIds+3));

   589 						result=logger.SetSecondaryFiltersEnabled(setfilter,ETrue);//C.A. previously:result=logger.EnableModuleUids(setfilter);

   590 						if(result==KErrNone)

   591 						{

   592 							INFO_PRINTF1(_L("More secondary filters than available can be set. Failed"));

   593 							result=1;

   594 						}

   595 						else

   596 						{

   597 							INFO_PRINTF1(_L("More secondary filters than available cannot be set. Passed"));

   598 							result=0;

   599 						}

   600 					}

   601 				}

   602 				INFO_PRINTF1(_L("Now call clear config to check removing multiple second filters performance"));

   603 				configIni.Clear(logger);

   604 				INFO_PRINTF1(_L("after clear config- multiple second filters performance"));

   605 

   606 				if(result==1)

   607 					SetBlockResult(EFail);

   608 				else

   609 					SetBlockResult(EPass);

   610 			}

   611 			logger.Close();

   612 			//  **************   Block end ****************

   613 		}

   614 	  return ETrue;

   615 	}

   616 

   617 

   618 /*******************************************************************************/

   619 /*********************************Logging Start/Stop Test***********************/

   620 /*******************************************************************************/

   621 

   622 CTCMLoggingWrapper::~CTCMLoggingWrapper()

   623 /**

   624  * Destructor

   625  */

   626 	{

   627 	}

   628 

   629 CTCMLoggingWrapper::CTCMLoggingWrapper()

   630 /**

   631  * Constructor

   632  */

   633 	{

   634 	}

   635 

   636 

   637 

   638 CTCMLoggingWrapper* CTCMLoggingWrapper::NewLC()

   639 	{

   640 	CTCMLoggingWrapper* self = new (ELeave)CTCMLoggingWrapper();

   641 	CleanupStack::PushL(self);

   642 	self->ConstructL();

   643 	return self;

   644 	}

   645 

   646 CTCMLoggingWrapper* CTCMLoggingWrapper::NewL()

   647 	{

   648 	CTCMLoggingWrapper* self=CTCMLoggingWrapper::NewLC();

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

   650 	return self;

   651 	}

   652 

   653 void CTCMLoggingWrapper::ConstructL()

   654 	{

   655 	}

   656 

   657 TAny* CTCMLoggingWrapper::GetObject()

   658 	{

   659 	return NULL;

   660 	}

   661 TBool CTCMLoggingWrapper::DoCommandL(	const TTEFFunction& /*aCommand*/,

   662 					const TTEFSectionName& /*aSection*/, 

   663 					const TInt /*aAsyncErrorIndex*/)

   664 	{

   665 		TBool OstStatus=0;

   666 	  if (BlockResult()==EPass)

   667 		{

   668 		//  ************** Delete the Block, the block start ****************

   669 

   670 			INFO_PRINTF1(_L("About to test ulogger start with one primary and one secondary"));  //Block start

   671 			TInt result=0;

   672 			RULogger logger;

   673 			result=logger.Connect();

   674       		  INFO_PRINTF2(_L("Connection to Ulogger: %d, attempt: 1"), result);

   675         	    if (result!=KErrNone)

   676          	  	 {

   677          	   		INFO_PRINTF1(_L("Connection to Ulogger failed. Will try to connect max. 10 times"));

   678           	  		for (TInt i=2; i<12;i++)

   679               		 {

   680                		User::After(1000);

   681                		result = logger.Connect();

   682                		INFO_PRINTF3(_L("Connection to Ulogger: %d, attempt: %d"), result, i);

   683                		if (result==KErrNone)

   684                     	{

   685                     	break;

   686                     	}

   687                		}

   688             	}

   689 #ifdef SysStartTest

   690 			TInt SysStartResult=logger.StartOutputting();

   691 			if(SysStartResult!=KErrInUse)

   692 				INFO_PRINTF2(_L("Logger start returning incorrect error code of %d when already started by SysStart, should be KErrInUse (-14)"), SysStartResult);

   693 			logger.StopOutputting();

   694 #endif

   695 #ifndef SysStartTest

   696 			CClearConfig configIni;

   697 			configIni.Clear(logger);

   698 #endif

   699 			CArrayFixFlat<TUint8> *setprimfilter = new (ELeave)CArrayFixFlat<TUint8>(22);

   700 			setprimfilter->AppendL(KGroupId);

   701 			setprimfilter->AppendL(TRACE_PERFORMANCE); 

   702 			setprimfilter->AppendL(TRACE_STATE);

   703 			setprimfilter->AppendL(TRACE_FLOW);

   704 			/**REMOVE THIS SECTION WHEN TRACE COMPILER WORK FOR CORRECT GIDS IS DONE**/

   705 			setprimfilter->AppendL(TRACE_NORMAL);

   706 			/*************************************************************************/

   707 			RArray<TUint32> setsecondfilter;

   708 			setsecondfilter.Append((TUint32) KComponentId);

   709 			logger.SetPrimaryFiltersEnabled(*setprimfilter,ETrue);//C.A. previously:logger.EnableClassifications(*setprimfilter);

   710 			logger.SetSecondaryFiltersEnabled(setsecondfilter,ETrue);//C.A. previously:logger.EnableModuleUids(setsecondfilter);

   711 			INFO_PRINTF1(_L("about to set file as output plugin"));

   712 			//NB: this of course assumes that the plugin functionality works which is tested more rigorously in the plugin test step

   713 #ifndef SysStartTest

   714 

   715 			_LIT(KTextvalue, "C:\\logs\\ULoggerLoggingTest.utf");

   716 #ifdef TE_UPT_TRACE_ENABLED

   717 			EmptyFile(KTextvalue);

   718 #endif

   719 			if(result==0)

   720 			{

   721 				INFO_PRINTF1(_L("file set as output plugin ok"));

   722 				_LIT8(KTextmedia,"uloggerfileplugin");

   723 				TPtrC8 mediaptr(KTextmedia);

   724 				result=logger.ActivateOutputPlugin(mediaptr);//C.A. previously:result=logger.SetActiveOutputPlugin(mediaptr);

   725 				INFO_PRINTF1(_L("file set as active output plugin ok"));

   726 				TPluginConfiguration pluginConfig;

   727 				pluginConfig.SetKey(KTextsetting);

   728 				pluginConfig.SetValue(KTextvalue);

   729 				result=logger.SetPluginConfigurations(mediaptr, pluginConfig);

   730 				if(result==0)

   731 					INFO_PRINTF1(_L("output plugin settings set ok"));

   732 				else

   733 					INFO_PRINTF2(_L("setting output plugin settings failed with err %d"), result);

   734 			}

   735 			else

   736 				INFO_PRINTF2(_L("add file as output plugin failed with err %d"), result);

   737 #endif

   738 			if(result==0)

   739 			{

   740 			/************** Start Logging to File****************/

   741 

   742 			result=logger.Start();//C.A. previously:result=logger.StartOutputting();

   743 			INFO_PRINTF2(_L("ulogger start returns error %d"), result);

   744 			INFO_PRINTF1(_L("now step over some Ost statements"));

   745 			int tracetag =0;

   746 			TBool ret=KErrNone;

   747 			iApiRunConfig.iDoStack=EFalse;

   748 

   749 			#ifdef TE_UPT_TRACE_ENABLED

   750 			OstStatus = 1;

   751 			INFO_PRINTF1(_L("TRACING HAS BEEN ENABLED!"));

   752   			#else

   753 			OstStatus = 0;

   754 			INFO_PRINTF1(_L("TRACING HAS BEEN DISABLED! All Log files should be empty/not exist"));

   755   			#endif

   756 

   757 			/*************Now test the static method************************/

   758 

   759 			INFO_PRINTF1(_L("******Testing STATIC Trace Methods******"));

   760 

   761 			iApiRunConfig.iDoStack=EFalse;

   762 			ret=KErrNone;

   763 			/*Comment out this line to switch off tracing as a negative test*/

   764 			for(tracetag=EUptTrace; tracetag!=(EOstTraceEventStop+1)&&ret==KErrNone;tracetag++)

   765 			{

   766                 iApiRunConfig.iApiId = tracetag;

   767                 ret = 1;

   768                 TApiRunResults apiRunResults;

   769                 TRunConfigurer::Init(apiRunResults);

   770                 ret = iTestTracer.SendTraceL(iApiRunConfig, apiRunResults);

   771                 INFO_PRINTF3(_L("Ost macro %d has executed with error %d"), tracetag, ret);

   772 

   773                 if(ret==KErrNone&&OstStatus)

   774                     {

   775                     StoreTraceInfo(ETrue,(TUPTApiUsed)tracetag,0, 0,iApiRunConfig.iHasContext, iApiRunConfig.iHasProgramCounter);

   776                     }

   777 			}

   778 

   779 			if((ret==KErrNone&&OstStatus)||(ret!=KErrNone&&!OstStatus&&tracetag!=EUptIsTraceActive))

   780 			{

   781 				result=0;

   782 				INFO_PRINTF1(_L("Tracing carried out succesfully for static method"));

   783 				if(ret==KErrNone)

   784 					{

   785 					INFO_PRINTF1(_L("logfile should contain appropriate tracing"));

   786 					}

   787 				else

   788 					INFO_PRINTF1(_L("logfile should be empty of trace statements"));

   789 

   790 			}

   791 			else

   792 			{

   793 				result=1;

   794 				INFO_PRINTF2(_L("Tracing Failed on Ost macro  %d for static method"), tracetag);

   795 			}

   796 

   797 			/************** Stop Logging to File****************/

   798 

   799 			result=logger.Stop();//C.A. previously:result=logger.StopOutputting();

   800 			if(result==KErrNone&&OstStatus)

   801 				{

   802 				if(!ReadFromLogFile(KTextvalue))

   803 					{

   804 					result=CompareTraces();

   805 					if(result)

   806 						INFO_PRINTF2(_L("ERROR: Error when comparing traces, error %i"), result);

   807 					//prob set the test step result here

   808 					}

   809 				}

   810 

   811 			if(result==0)

   812 			{

   813 			iApiRunConfig.iApiId = EUptTrace;

   814 			ret = 0;

   815 			TApiRunResults apiRunResults;

   816 			TRunConfigurer::Init(apiRunResults);

   817 			ret = iTestTracer.SendTraceL(iApiRunConfig, apiRunResults);

   818 			INFO_PRINTF1(_L("logfile should contain appropriate tracing without an extra Ost(0) trace at the end, if it is present ULogger.StopOutputting() has failed in functionality"));

   819 			if(!ret)

   820 				{

   821 				result=CompareTraces();

   822 				if(result)

   823 					INFO_PRINTF2(_L("ERROR: Error when comparing traces, extra trace might have been added at the end %i"), result);

   824 				}

   825 			}

   826 			else

   827 			{

   828 				INFO_PRINTF2(_L("Call to Ulogger.StopOutputting() has failed with err %d"), result);

   829 			}

   830 		}

   831 		else

   832 			INFO_PRINTF1(_L("adding file as output plugin failed"));

   833 		if(result==0)

   834 				SetBlockResult(EPass);

   835 		else

   836 				SetBlockResult(EFail);

   837 		INFO_PRINTF1(_L("Simple logging to file has been tested - check output log"));

   838 

   839 		/***************************negative test***********************/

   840 		_LIT(KnegTextvalue, "C:\\logs\\ULoggerNegativeLoggingTest.utf");

   841 #ifdef TE_UPT_TRACE_ENABLED

   842 		EmptyFile(KnegTextvalue);

   843 #endif

   844 		if(BlockResult()==EPass)

   845 		{

   846 			INFO_PRINTF1(_L("Now do some negative logging testing."));

   847 			if(result==KErrNone)

   848 			{

   849 				INFO_PRINTF1(_L("file set as output plugin ok"));

   850 				_LIT8(KTextmedia,"uloggerfileplugin");

   851 				TPtrC8 mediaptr(KTextmedia);

   852 				if(result==0)

   853 				{	INFO_PRINTF1(_L("file set as active output plugin ok"));

   854 					TPluginConfiguration negPluginConfig;

   855 					negPluginConfig.SetKey(KTextsetting);

   856 					negPluginConfig.SetValue(KnegTextvalue);

   857 					result=logger.SetPluginConfigurations(mediaptr, negPluginConfig);

   858 					if(result==0)

   859 						INFO_PRINTF1(_L("output plugin settings set ok"));

   860 					else

   861 						INFO_PRINTF1(_L("setting output plugin settings failed"));

   862 				}

   863 				else

   864 					INFO_PRINTF1(_L("file not set as active output plugin - failed"));

   865 				INFO_PRINTF1(_L("Log over traces with different filters set - there should only be one line in logfile corrseponding to the set filters."));

   866 				if(result==0)

   867 				{

   868 				logger.Start();//C.A. previously:logger.StartOutputting();

   869 

   870 					/*****do the tracing**************/

   871 

   872 				bool ret = 1;

   873 				TTraceContext header(KComponentId, KGroupId, iApiRunConfig.iHasContext, iApiRunConfig.iHasProgramCounter);

   874 				ret = OstTrace(header, KTraceId);

   875 

   876 				iLoggedTraces.Reset();

   877 				iSentTraces.Reset();

   878 				if (ret)

   879 					{

   880 					//create trace information object

   881 					StoreTraceInfo(EFalse,(TUPTApiUsed)0,KComponentId, KGroupId,iApiRunConfig.iHasContext, iApiRunConfig.iHasProgramCounter);

   882 					}

   883 

   884 				INFO_PRINTF2(_L("tracing ret %d"), ret);

   885 				TTraceContext attr1(KComponentId+1, KGroupId+1, iApiRunConfig.iHasContext, iApiRunConfig.iHasProgramCounter);

   886 				ret = OstTrace(attr1, KTraceId);

   887 

   888 				INFO_PRINTF2(_L("tracing ret %d"), ret);

   889 

   890 				/************** Stop Logging to File****************/

   891 

   892 				result=logger.Stop();//C.A. previously:result=logger.StopOutputting();

   893 				if(result!=0)

   894 					{

   895 					INFO_PRINTF2(_L("Call to Ulogger.StopOutputting() has failed with err %d"), result);

   896 					}

   897 					INFO_PRINTF1(_L("Set some more filters and remove the original set in ulogger, then trace over the original types of traces - there should be no extra lines in logfile above"));

   898 

   899 				/**************Now Change the filter settings********/

   900 				CArrayFixFlat<TUint8> *removeprimfilter = new (ELeave)CArrayFixFlat<TUint8>(1);

   901 				removeprimfilter->AppendL(setprimfilter->At(0));

   902 				RArray<TUint32> removesecondfilter;

   903 				removesecondfilter.Append(setsecondfilter[0]);

   904 				result=logger.SetPrimaryFiltersEnabled(*removeprimfilter,EFalse);//C.A. previously:result=logger.DisableClassifications(*removeprimfilter);

   905 				if(result==0)

   906 				{

   907 					INFO_PRINTF1(_L("Call to removeprimary has passed"));

   908 				}

   909 				result=logger.SetSecondaryFiltersEnabled(removesecondfilter,EFalse);//C.A. previously:result=logger.DisableModuleUids(removesecondfilter);

   910 				if(result==0)

   911 				{

   912 						INFO_PRINTF1(_L("Call to removesecondary has passed"));

   913 				}

   914 					CArrayFixFlat<TUint8> *newsetprimfilter = new (ELeave)CArrayFixFlat<TUint8>(1);

   915 					newsetprimfilter->AppendL((TUint8)(KGroupId+2));

   916 					RArray<TUint32> newsetsecondfilter;

   917 					newsetsecondfilter.Append((TUint32) (KComponentId+2));

   918 					logger.SetPrimaryFiltersEnabled(*newsetprimfilter,ETrue);//C.A. previously:logger.EnableClassifications(*newsetprimfilter);

   919 					logger.SetSecondaryFiltersEnabled(newsetsecondfilter,ETrue);//C.A. previously:logger.EnableModuleUids(newsetsecondfilter);

   920 					ret=1;

   921 					logger.Start();//C.A. previously:logger.StartOutputting();

   922 

   923 					/*****do the tracing**************/

   924 

   925 					/*Comment out this line to switch off tracing as a negative test*/

   926 					int tracetag=0;

   927 					for(tracetag=EUptTrace; tracetag!=EUptIsTraceActive&&ret==KErrNone;tracetag++)

   928 					{

   929 					iApiRunConfig.iApiId = tracetag;

   930 					ret = 1;

   931 					TApiRunResults apiRunResults;

   932 					TRunConfigurer::Init(apiRunResults);

   933 					ret = iTestTracer.SendTraceL(iApiRunConfig, apiRunResults);

   934 					INFO_PRINTF3(_L("Ost macro %d has been executed with error %d"), tracetag, ret);

   935 					}

   936 					if(ret==KErrNone)

   937 					{

   938 						SetBlockResult(EFail);

   939 						INFO_PRINTF1(_L("BTrace filters are not being reset with StartOutputting()/StopOutputting(), so logging over filters that have been unset is occuring. Fail"));

   940 					}

   941 					TTraceContext attr2(KComponentId+2, KGroupId+2, iApiRunConfig.iHasContext, iApiRunConfig.iHasProgramCounter);

   942 					ret = OstTrace(attr2, KTraceId);

   943 					if (ret)

   944 						{

   945 						//create trace information object

   946 						StoreTraceInfo(EFalse,(TUPTApiUsed)0,KComponentId+2, KGroupId+2,iApiRunConfig.iHasContext, iApiRunConfig.iHasProgramCounter);

   947 						}

   948 

   949 					INFO_PRINTF2(_L("tracing ret %d"), ret);

   950 

   951 					/************** Stop Logging to File****************/

   952 

   953 					logger.Stop();//C.A. previously:result=logger.StopOutputting();

   954 

   955 					if(result!=0)

   956 					{

   957 					INFO_PRINTF2(_L("Call to Ulogger.StopOutputting() has failed with err %d"), result);

   958 					}

   959 

   960 					else if(result==KErrNone&&OstStatus)

   961 						{

   962 						if(!ReadFromLogFile(KnegTextvalue))

   963 							{

   964 							result=CompareTraces();

   965 							if(result)

   966 								INFO_PRINTF2(_L("ERROR: Error when comparing traces, error %i"), result);

   967 							//prob set the test step result here

   968 							}

   969 						}

   970 					if(newsetprimfilter)

   971 					{

   972 						delete(newsetprimfilter);

   973 						newsetprimfilter=NULL;

   974 					}

   975 				}

   976 			}

   977 			else

   978 				INFO_PRINTF1(_L("Incorrect error code when trying to add file as a plug-in when it already exists"));

   979 			if(result==0&&BlockResult()==EPass)

   980 					SetBlockResult(EPass);

   981 			else

   982 					SetBlockResult(EFail);

   983 			INFO_PRINTF1(_L("Simple negative logging to file has been tested - check output log"));

   984 		}

   985 

   986 		/***************************multiple type test***********************/

   987    		 // From negative test: primary has been set to KClassification+2 and secondary to KComponentId+2

   988 		_LIT(KmultTextvalue, "C:\\logs\\ULoggerMultipleLoggingTest.utf");

   989 #ifdef TE_UPT_TRACE_ENABLED

   990 		EmptyFile(KmultTextvalue);

   991 #endif

   992 		if(BlockResult()==EPass)

   993 		{

   994 			INFO_PRINTF1(_L("Now do some multiple type logging testing."));

   995 			//CClearConfig configIni;

   996 			//configIni.Clear(logger);

   997 

   998 			if(result==0)

   999 			{

  1000 				INFO_PRINTF1(_L("file set as output plugin ok"));

  1001 				_LIT8(KTextmedia,"uloggerfileplugin");

  1002 				TPtrC8 mediaptr(KTextmedia);

  1003 				if(result==0)

  1004 				{

  1005 					INFO_PRINTF1(_L("file set as active output plugin ok"));

  1006 					TPluginConfiguration pluginConfig;

  1007 					pluginConfig.SetKey(KTextsetting);

  1008 					pluginConfig.SetValue(KmultTextvalue);

  1009 					result=logger.SetPluginConfigurations(mediaptr, pluginConfig);

  1010 					if(result==0)

  1011 						INFO_PRINTF1(_L("output plugin settings set ok"));

  1012 					else

  1013 						INFO_PRINTF1(_L("setting output plugin settings failed"));

  1014 				}

  1015 				else

  1016 					INFO_PRINTF1(_L("file not set as active output plugin - failed"));

  1017 				if(result==0)

  1018 				{

  1019 					TInt i;

  1020 					CArrayFixFlat<TUint8> *multsetprimfilter = new (ELeave)CArrayFixFlat<TUint8>(1);

  1021 					multsetprimfilter->AppendL(KGroupId);

  1022 					RArray<TUint32> multsetsecondfilter;

  1023 					multsetsecondfilter.Append((TUint32) (KComponentId));

  1024 					logger.SetPrimaryFiltersEnabled(*multsetprimfilter,ETrue);//C.A. previously:logger.EnableClassifications(*multsetprimfilter);

  1025 					TInt errCode = logger.SetSecondaryFiltersEnabled(multsetsecondfilter,ETrue);//C.A. previously:TInt errCode = logger.EnableModuleUids(multsetsecondfilter);

  1026 

  1027 					if(errCode != KErrNone)

  1028 						INFO_PRINTF2(_L("Setting secondary filters failed: %d"), errCode);

  1029 					INFO_PRINTF1(_L("checking !!! secondary filters"));

  1030 					for(i=0; i<multsetsecondfilter.Count(); ++i)

  1031 						{

  1032 						TBuf<16> buf;

  1033 						buf.AppendFormat(_L("%d"), multsetsecondfilter[i]);

  1034 						INFO_PRINTF1(buf);

  1035 						}

  1036 

  1037 					INFO_PRINTF1(_L("Now given the two sets of set filters, step over traces of each type, some with matching primary but not secondary and vice versa"));

  1038 

  1039 					INFO_PRINTF1(_L("Primary Filetrs:"));

  1040 					CArrayFixFlat<TUint8>* primFilters = new (ELeave) CArrayFixFlat<TUint8>(1);

  1041 					CleanupStack::PushL(primFilters);

  1042 					logger.GetPrimaryFiltersEnabled(*primFilters);//C.A. previously:logger.GetEnabledClassifications(*primFilters);

  1043 

  1044 					for(i=0; i<primFilters->Count(); ++i)

  1045 						{

  1046 						TBuf<16> buf;

  1047 						buf.AppendFormat(_L("%d "), primFilters->At(i));

  1048 						INFO_PRINTF1(buf);

  1049 						}

  1050 					CleanupStack::PopAndDestroy(); //primFiletrs

  1051 

  1052 					INFO_PRINTF1(_L("ModuleUids:"));

  1053 					RArray<TUint32> secFilters;

  1054 					errCode = logger.GetSecondaryFiltersEnabled(secFilters);//C.A. previously:errCode = logger.GetEnabledModuleUids(secFilters);

  1055 					if(errCode != KErrNone)

  1056 						INFO_PRINTF2(_L("Getting ModuleUids failed: %d"), errCode);

  1057 

  1058 					for(i=0; i<secFilters.Count(); ++i)

  1059 						{

  1060 						TBuf<16> buf;

  1061 						buf.AppendFormat(_L("%d"), secFilters[i]);

  1062 						INFO_PRINTF1(buf);

  1063 						}

  1064 					secFilters.Close();

  1065 

  1066 					INFO_PRINTF1(_L("Secondary Filetring is:"));

  1067 					TBool secF = EFalse;

  1068 					logger.GetSecondaryFilteringEnabled(secF);//C.A. previously:logger.IsModuleUidFilteringEnabled(secF);

  1069 					if(secF)

  1070 						INFO_PRINTF1(_L("ENABLED"));

  1071 					else

  1072 						INFO_PRINTF1(_L("DISABLED"));

  1073 

  1074 					result=logger.Start();//C.A. previously:result=logger.StartOutputting();

  1075 					if(result!=KErrNone)

  1076 						INFO_PRINTF2(_L("ulogger server didn't start, with error %d"), result);

  1077 

  1078 					/*****do the tracing**************/

  1079 

  1080 #ifdef TE_UPT_TRACE_ENABLED

  1081 		OstStatus = 1;

  1082 		INFO_PRINTF1(_L("TRACING HAS BEEN ENABLED!"));

  1083 #else

  1084 		OstStatus = 0;

  1085 		INFO_PRINTF1(_L("TRACING HAS BEEN DISABLED! All Log files should be empty/not exist"));

  1086 #endif

  1087 					iLoggedTraces.Reset();

  1088 					iSentTraces.Reset();

  1089 					bool ret=0;

  1090 					TTraceContext attributes(KComponentId, KGroupId, iApiRunConfig.iHasContext, iApiRunConfig.iHasProgramCounter);

  1091 					ret = OstTrace(attributes, KTraceId);

  1092 

  1093 					if(ret==0&&OstStatus)

  1094 						{

  1095 						SetBlockResult(EFail);

  1096 						INFO_PRINTF1(_L("logging over filters that have been set (both sec and prim) is not occuring. Fail"));

  1097 						}

  1098 					else

  1099 						{

  1100 						if (ret==1&&OstStatus)

  1101 							{

  1102 							//create trace information object

  1103 							StoreTraceInfo(EFalse,(TUPTApiUsed)0,KComponentId, KGroupId,iApiRunConfig.iHasContext, iApiRunConfig.iHasProgramCounter);

  1104 							}

  1105 						}

  1106 

  1107 					TTraceContext attr1(KComponentId + 1, KGroupId + 1, iApiRunConfig.iHasContext, iApiRunConfig.iHasProgramCounter);

  1108 					ret = OstTrace(attr1, KTraceId);

  1109 					if(ret==1)

  1110 					{

  1111 						SetBlockResult(EFail);

  1112 						INFO_PRINTF1(_L("logging over filters that have not been set is occuring. Fail"));

  1113 					}

  1114 					TTraceContext attr2(KComponentId + 2, KGroupId, iApiRunConfig.iHasContext, iApiRunConfig.iHasProgramCounter);

  1115 					ret = OstTrace(attr2, KTraceId);

  1116 					if(ret==0&&OstStatus)

  1117 					{

  1118 						SetBlockResult(EFail);

  1119 						INFO_PRINTF1(_L("logging over filters that have been set (both sec+2 and prim) is not occuring. Fail"));

  1120 					}

  1121 					else

  1122 						{

  1123 						if (ret==1&&OstStatus)

  1124 							{

  1125 							//create trace information object

  1126 							StoreTraceInfo(EFalse,(TUPTApiUsed)0,KComponentId+2, KGroupId,iApiRunConfig.iHasContext, iApiRunConfig.iHasProgramCounter);

  1127 							}

  1128 						}

  1129 

  1130 					TTraceContext attr3(KComponentId, KGroupId + 2, iApiRunConfig.iHasContext, iApiRunConfig.iHasProgramCounter);

  1131 					ret = OstTrace(attr3, KTraceId);

  1132 					if(ret==0&&OstStatus)

  1133 					{

  1134 						SetBlockResult(EFail);