Mercurial Mercurial > oss > MCL > sf > os > cellularsrv / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
telephonyserverplugins/simtsy/src/CSimPacketQoS.cpp
branchRCL_3
changeset 19 630d2f34d719
parent 0 3553901f7fa8
child 20 07a122eea281
equal deleted inserted replaced
18:17af172ffa5f 19:630d2f34d719 
     1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
 
     1 // Copyright (c) 1997-2010 Nokia Corporation and/or its subsidiary(-ies).
 
     2 // All rights reserved.
 
     2 // All rights reserved.
 
     3 // This component and the accompanying materials are made available
 
     3 // This component and the accompanying materials are made available
 
     4 // under the terms of "Eclipse Public License v1.0"
 
     4 // under the terms of "Eclipse Public License v1.0"
 
     5 // which accompanies this distribution, and is available
 
     5 // which accompanies this distribution, and is available
 
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
    11 // Contributors:
 
    11 // Contributors:
 
    12 //
 
    12 //
 
    13 // Description:
 
    13 // Description:
 
    14 //
 
    14 //
 
    15 
    15 
       
    16 
       
    17 
       
    18 #include "OstTraceDefinitions.h"
 
       
    19 #ifdef OST_TRACE_COMPILER_IN_USE
 
       
    20 #include "CSimPacketQoSTraces.h"
 
       
    21 #endif
 
       
    22 
    16 #include "CSimPacketQoS.h"
 
    23 #include "CSimPacketQoS.h"
 
    17 #include "CSimPhone.h"
 
    24 #include "CSimPhone.h"
 
    18 #include <pcktcs.h>
 
    25 #include <pcktcs.h>
 
    19 #include "CSimPacketContext.h"
 
    26 #include "CSimPacketContext.h"
 
    20 #include "Simlog.h"
 
       
    21 #include "utils.h"
 
    27 #include "utils.h"
 
    22 #include "CSimPubSubChange.h"
 
    28 #include "CSimPubSubChange.h"
 
    23 
    29 
    24 static const int KNumberofProfiles = 4;	//< Number chosen at random.  
    30 static const int KNumberofProfiles = 4;	//< Number chosen at random.  
    25 
    31 
   235 * Constructs all the member data and retrieves all the data from the config file specific to this class.
 
   241 * Constructs all the member data and retrieves all the data from the config file specific to this class.
 
   236 *
 
   242 *
 
   237 * @leave Leaves no memory or any data member does not construct for any reason.
 
   243 * @leave Leaves no memory or any data member does not construct for any reason.
 
   238 */
 
   244 */
 
   239 	{
 
   245 	{
 
   240 	LOGPACKET1("CSimPacketQoS: Entered constructor");
 
   246 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_CONSTRUCTL_1, "CSimPacketQoS: Entered constructor");
 
   241 	iQosNetworkNotificationCount = 0;
 
   247 	iQosNetworkNotificationCount = 0;
 
   242 	iQosR5NetworkNotificationCount = 0;
 
   248 	iQosR5NetworkNotificationCount = 0;
 
   243 
   249 
   244 	iTimer=CSimTimer::NewL(iPhone);
 
   250 	iTimer=CSimTimer::NewL(iPhone);
 
   245 	iSetQoSData = new (ELeave) CArrayFixFlat<TSetQoSData>(1);
 
   251 	iSetQoSData = new (ELeave) CArrayFixFlat<TSetQoSData>(1);
 
   246  	iSetQoSTimer = CSimTimer::NewL(iPhone);
 
   252  	iSetQoSTimer = CSimTimer::NewL(iPhone);
 
   247 	iSimQoSChange = CSimPubSubChange::NewL(this, CSimPubSub::TPubSubProperty(KUidPSSimTsyCategory, KPSSimTsyNetworkQoSChange, KPSSimTsyNetworkQoSChangeKeyType));
 
   253 	iSimQoSChange = CSimPubSubChange::NewL(this, CSimPubSub::TPubSubProperty(KUidPSSimTsyCategory, KPSSimTsyNetworkQoSChange, KPSSimTsyNetworkQoSChangeKeyType));
 
   248 	
   254 	
   249 	LOGPACKET1("Starting to Load and Parse Packet Qos Config File");
 
   255 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_CONSTRUCTL_2, "Starting to Load and Parse Packet Qos Config File");
 
   250 
   256 
   251 	GetGPRSReqProfilesL();
 
   257 	GetGPRSReqProfilesL();
 
   252 	GetGPRSNegProfilesL();
 
   258 	GetGPRSNegProfilesL();
 
   253 	GetR99ReqProfilesL();
 
   259 	GetR99ReqProfilesL();
 
   254 	GetR99NegProfilesL();
 
   260 	GetR99NegProfilesL();
 
   260 	GetR99QosProfileCaps();
 
   266 	GetR99QosProfileCaps();
 
   261 	GetR5QosProfileCaps();
 
   267 	GetR5QosProfileCaps();
 
   262 	GetProfileFailSettings();
 
   268 	GetProfileFailSettings();
 
   263 	GetSetQoSSettings();
 
   269 	GetSetQoSSettings();
 
   264 
   270 
   265 	LOGPACKET1("...Finished parsing Packet qos config parameters...");
 
   271 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_CONSTRUCTL_3, "...Finished parsing Packet qos config parameters...");
 
   266 	}
 
   272 	}
 
   267 
   273 
   268 void CSimPacketQoS::GetGPRSReqProfilesL()
 
   274 void CSimPacketQoS::GetGPRSReqProfilesL()
 
   269 	{
 
   275 	{
 
   270 	TProfileConfig profile;
 
   276 	TProfileConfig profile;
 
   285 		TPtrC8 minReliability, reqReliability, minMean, reqMean;
 
   291 		TPtrC8 minReliability, reqReliability, minMean, reqMean;
 
   286 
   292 
   287 		TInt ret = CTestConfig::GetElement(item->Value(),KStdDelimiter,0,minPrecedence);
 
   293 		TInt ret = CTestConfig::GetElement(item->Value(),KStdDelimiter,0,minPrecedence);
 
   288 		if(ret!=KErrNone)
 
   294 		if(ret!=KErrNone)
 
   289 			{
 
   295 			{
 
   290 			LOGPARSERR("QosProfileReqGPRS::minPrecedence",ret,0,&KQosProfileReqGPRS);
 
   296 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSREQPROFILESL_1, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQGPRS::MINPRECEDENCE returned %d (element no. %d) from tag %s.",ret,0,KQosProfileReqGPRS);
 
   291 			continue;
 
   297 			continue;
 
   292 			}
 
   298 			}
 
   293 		else
 
   299 		else
 
   294 			{
 
   300 			{
 
   295 			if(AsciiToNum(minPrecedence, digit)==KErrNone)
 
   301 			if(AsciiToNum(minPrecedence, digit)==KErrNone)
 
   297 			}
 
   303 			}
 
   298 
   304 
   299 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,reqPrecedence);
 
   305 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,reqPrecedence);
 
   300 		if(ret!=KErrNone)
 
   306 		if(ret!=KErrNone)
 
   301 			{
 
   307 			{
 
   302 			LOGPARSERR("QosProfileReqGPRS::reqPrecedence",ret,1,&KQosProfileReqGPRS);
 
   308 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSREQPROFILESL_2, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQGPRS::REQPRECEDENCE returned %d (element no. %d) from tag %s.",ret,1,KQosProfileReqGPRS);
 
   303 			continue;
 
   309 			continue;
 
   304 			}
 
   310 			}
 
   305 		else
 
   311 		else
 
   306 			{
 
   312 			{
 
   307 			if(AsciiToNum(reqPrecedence, digit)==KErrNone)
 
   313 			if(AsciiToNum(reqPrecedence, digit)==KErrNone)
 
   309 			}
 
   315 			}
 
   310 
   316 
   311 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,minDelay);
 
   317 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,minDelay);
 
   312 		if(ret!=KErrNone)
 
   318 		if(ret!=KErrNone)
 
   313 			{
 
   319 			{
 
   314 			LOGPARSERR("QosProfileReqGPRS::minDelay",ret,2,&KQosProfileReqGPRS);
 
   320 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSREQPROFILESL_3, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQGPRS::MINDELAY returned %d (element no. %d) from tag %s.",ret,2,KQosProfileReqGPRS);
 
   315 			continue;
 
   321 			continue;
 
   316 			}
 
   322 			}
 
   317 		else
 
   323 		else
 
   318 			{
 
   324 			{
 
   319 			if(AsciiToNum(minDelay, digit)==KErrNone)
 
   325 			if(AsciiToNum(minDelay, digit)==KErrNone)
 
   321 			}
 
   327 			}
 
   322 
   328 
   323 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,reqDelay);
 
   329 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,reqDelay);
 
   324 		if(ret!=KErrNone)
 
   330 		if(ret!=KErrNone)
 
   325 			{
 
   331 			{
 
   326 			LOGPARSERR("QosProfileReqGPRS::reqDelay",ret,3,&KQosProfileReqGPRS);
 
   332 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSREQPROFILESL_4, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQGPRS::REQDELAY returned %d (element no. %d) from tag %s.",ret,3,KQosProfileReqGPRS);
 
   327 			continue;
 
   333 			continue;
 
   328 			}
 
   334 			}
 
   329 		else
 
   335 		else
 
   330 			{
 
   336 			{
 
   331 			if(AsciiToNum(reqDelay, digit)==KErrNone)
 
   337 			if(AsciiToNum(reqDelay, digit)==KErrNone)
 
   333 			}
 
   339 			}
 
   334 
   340 
   335 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,minReliability);
 
   341 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,minReliability);
 
   336 		if(ret!=KErrNone)
 
   342 		if(ret!=KErrNone)
 
   337 			{
 
   343 			{
 
   338 			LOGPARSERR("QosProfileReqGPRS::minReliability",ret,4,&KQosProfileReqGPRS);
 
   344 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSREQPROFILESL_5, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQGPRS::MINRELIABILITY returned %d (element no. %d) from tag %s.",ret,4,KQosProfileReqGPRS);
 
   339 			continue;
 
   345 			continue;
 
   340 			}
 
   346 			}
 
   341 		else
 
   347 		else
 
   342 			{
 
   348 			{
 
   343 			if(AsciiToNum(minReliability, digit)==KErrNone)
 
   349 			if(AsciiToNum(minReliability, digit)==KErrNone)
 
   345 			}
 
   351 			}
 
   346 
   352 
   347 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,reqReliability);
 
   353 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,reqReliability);
 
   348 		if(ret!=KErrNone)
 
   354 		if(ret!=KErrNone)
 
   349 			{
 
   355 			{
 
   350 			LOGPARSERR("QosProfileReqGPRS::reqReliability",ret,5,&KQosProfileReqGPRS);
 
   356 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSREQPROFILESL_6, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQGPRS::REQRELIABILITY returned %d (element no. %d) from tag %s.",ret,5,KQosProfileReqGPRS);
 
   351 			continue;
 
   357 			continue;
 
   352 			}
 
   358 			}
 
   353 		else
 
   359 		else
 
   354 			{
 
   360 			{
 
   355 			if(AsciiToNum(reqReliability, digit)==KErrNone)
 
   361 			if(AsciiToNum(reqReliability, digit)==KErrNone)
 
   357 			}
 
   363 			}
 
   358 
   364 
   359 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,minPeek);
 
   365 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,minPeek);
 
   360 		if(ret!=KErrNone)
 
   366 		if(ret!=KErrNone)
 
   361 			{
 
   367 			{
 
   362 			LOGPARSERR("QosProfileReqGPRS::minPeek",ret,6,&KQosProfileReqGPRS);
 
   368 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSREQPROFILESL_7, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQGPRS::MINPEEK returned %d (element no. %d) from tag %s.",ret,6,KQosProfileReqGPRS);
 
   363 			continue;
 
   369 			continue;
 
   364 			}
 
   370 			}
 
   365 		else
 
   371 		else
 
   366 			{
 
   372 			{
 
   367 			if(AsciiToNum(minPeek, digit)==KErrNone)
 
   373 			if(AsciiToNum(minPeek, digit)==KErrNone)
 
   369 			}
 
   375 			}
 
   370 
   376 
   371 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,reqPeek);
 
   377 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,reqPeek);
 
   372 		if(ret!=KErrNone)
 
   378 		if(ret!=KErrNone)
 
   373 			{
 
   379 			{
 
   374 			LOGPARSERR("QosProfileReqGPRS::reqPeek",ret,7,&KQosProfileReqGPRS);
 
   380 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSREQPROFILESL_8, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQGPRS::REQPEEK returned %d (element no. %d) from tag %s.",ret,7,KQosProfileReqGPRS);
 
   375 			continue;
 
   381 			continue;
 
   376 			}
 
   382 			}
 
   377 		else
 
   383 		else
 
   378 			{
 
   384 			{
 
   379 			if(AsciiToNum(reqPeek, digit)==KErrNone)
 
   385 			if(AsciiToNum(reqPeek, digit)==KErrNone)
 
   381 			}
 
   387 			}
 
   382 
   388 
   383 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,minMean);
 
   389 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,minMean);
 
   384 		if(ret!=KErrNone)
 
   390 		if(ret!=KErrNone)
 
   385 			{
 
   391 			{
 
   386 			LOGPARSERR("QosProfileReqGPRS::minMean",ret,8,&KQosProfileReqGPRS);
 
   392 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSREQPROFILESL_9, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQGPRS::MINMEAN returned %d (element no. %d) from tag %s.",ret,8,KQosProfileReqGPRS);
 
   387 			continue;
 
   393 			continue;
 
   388 			}
 
   394 			}
 
   389 		else
 
   395 		else
 
   390 			{
 
   396 			{
 
   391 			if(AsciiToNum(minMean, digit)==KErrNone)
 
   397 			if(AsciiToNum(minMean, digit)==KErrNone)
 
   393 			}
 
   399 			}
 
   394 
   400 
   395 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,reqMean);
 
   401 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,reqMean);
 
   396 		if(ret!=KErrNone)
 
   402 		if(ret!=KErrNone)
 
   397 			{
 
   403 			{
 
   398 			LOGPARSERR("QosProfileReqGPRS::reqMean",ret,9,&KQosProfileReqGPRS);
 
   404 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSREQPROFILESL_10, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQGPRS::REQMEAN returned %d (element no. %d) from tag %s.",ret,9,KQosProfileReqGPRS);
 
   399 			continue;
 
   405 			continue;
 
   400 			}
 
   406 			}
 
   401 		else
 
   407 		else
 
   402 			{
 
   408 			{
 
   403 			if(AsciiToNum(reqMean, digit)==KErrNone)
 
   409 			if(AsciiToNum(reqMean, digit)==KErrNone)
 
   427 		TPtrC8 negPrecedence, negDelay, negPeek, negReliability, negMean;
 
   433 		TPtrC8 negPrecedence, negDelay, negPeek, negReliability, negMean;
 
   428 
   434 
   429 		TInt ret = CTestConfig::GetElement(item->Value(),KStdDelimiter,0,negPrecedence);
 
   435 		TInt ret = CTestConfig::GetElement(item->Value(),KStdDelimiter,0,negPrecedence);
 
   430 		if(ret!=KErrNone)
 
   436 		if(ret!=KErrNone)
 
   431 			{
 
   437 			{
 
   432 			LOGPARSERR("QosProfileReqGPRS::negPrecedence",ret,0,&KQosProfileNegGPRS);
 
   438 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSNEGPROFILESL_1, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQGPRS::NEGPRECEDENCE returned %d (element no. %d) from tag %s.",ret,0,KQosProfileNegGPRS);
 
   433 			continue;
 
   439 			continue;
 
   434 			}
 
   440 			}
 
   435 		else
 
   441 		else
 
   436 			if(AsciiToNum(negPrecedence, digit)==KErrNone)
 
   442 			if(AsciiToNum(negPrecedence, digit)==KErrNone)
 
   437 				negProfile.iNegPrecedence = digit;
 
   443 				negProfile.iNegPrecedence = digit;
 
   438 
   444 
   439 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,negDelay);
 
   445 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,negDelay);
 
   440 		if(ret!=KErrNone)
 
   446 		if(ret!=KErrNone)
 
   441 			{
 
   447 			{
 
   442 			LOGPARSERR("QosProfileReqGPRS::negDelay",ret,1,&KQosProfileNegGPRS);
 
   448 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSNEGPROFILESL_2, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQGPRS::NEGDELAY returned %d (element no. %d) from tag %s.",ret,1,KQosProfileNegGPRS);
 
   443 			continue;
 
   449 			continue;
 
   444 			}
 
   450 			}
 
   445 		else
 
   451 		else
 
   446 			if(AsciiToNum(negDelay, digit)==KErrNone)
 
   452 			if(AsciiToNum(negDelay, digit)==KErrNone)
 
   447 				negProfile.iNegDelay = digit;
 
   453 				negProfile.iNegDelay = digit;
 
   448 
   454 
   449 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,negReliability);
 
   455 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,negReliability);
 
   450 		if(ret!=KErrNone)
 
   456 		if(ret!=KErrNone)
 
   451 			{
 
   457 			{
 
   452 			LOGPARSERR("QosProfileReqGPRS::negReliability",ret,2,&KQosProfileNegGPRS);
 
   458 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSNEGPROFILESL_3, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQGPRS::NEGRELIABILITY returned %d (element no. %d) from tag %s.",ret,2,KQosProfileNegGPRS);
 
   453 			continue;
 
   459 			continue;
 
   454 			}
 
   460 			}
 
   455 		else
 
   461 		else
 
   456 			if(AsciiToNum(negReliability, digit)==KErrNone)
 
   462 			if(AsciiToNum(negReliability, digit)==KErrNone)
 
   457 				negProfile.iNegReliability = digit;
 
   463 				negProfile.iNegReliability = digit;
 
   458 
   464 
   459 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,negPeek);
 
   465 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,negPeek);
 
   460 		if(ret!=KErrNone)
 
   466 		if(ret!=KErrNone)
 
   461 			{
 
   467 			{
 
   462 			LOGPARSERR("QosProfileReqGPRS::negPeek",ret,3,&KQosProfileNegGPRS);
 
   468 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSNEGPROFILESL_4, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQGPRS::NEGPEEK returned %d (element no. %d) from tag %s.",ret,3,KQosProfileNegGPRS);
 
   463 			continue;
 
   469 			continue;
 
   464 			}
 
   470 			}
 
   465 		else
 
   471 		else
 
   466 			if(AsciiToNum(negPeek, digit)==KErrNone)
 
   472 			if(AsciiToNum(negPeek, digit)==KErrNone)
 
   467 				negProfile.iNegPeekThroughput = digit;
 
   473 				negProfile.iNegPeekThroughput = digit;
 
   468 
   474 
   469 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,negMean);
 
   475 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,negMean);
 
   470 		if(ret!=KErrNone)
 
   476 		if(ret!=KErrNone)
 
   471 			{
 
   477 			{
 
   472 			LOGPARSERR("QosProfileReqGPRS::negMean",ret,4,&KQosProfileNegGPRS);
 
   478 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSNEGPROFILESL_5, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQGPRS::NEGMEAN returned %d (element no. %d) from tag %s.",ret,4,KQosProfileNegGPRS);
 
   473 			continue;
 
   479 			continue;
 
   474 			}
 
   480 			}
 
   475 		else
 
   481 		else
 
   476 			if(AsciiToNum(negMean, digit)==KErrNone)
 
   482 			if(AsciiToNum(negMean, digit)==KErrNone)
 
   477 				negProfile.iNegMeanThroughput = digit;
 
   483 				negProfile.iNegMeanThroughput = digit;
 
   508 		TInt minGuaranteedUpLinkBitRate, minGuaranteedDownLinkBitRate;
 
   514 		TInt minGuaranteedUpLinkBitRate, minGuaranteedDownLinkBitRate;
 
   509 
   515 
   510 		TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextName);
 
   516 		TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextName);
 
   511 		if(ret!=KErrNone)
 
   517 		if(ret!=KErrNone)
 
   512 			{
 
   518 			{
 
   513 			LOGPARSERR("QosProfileReqR99::contextName",ret,0,KQosProfileReqR99);
 
   519 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_1, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::CONTEXTNAME returned %d (element no. %d) from tag %s.",ret,0,KQosProfileReqR99);
 
   514 			continue;
 
   520 			continue;
 
   515 			}
 
   521 			}
 
   516 		else 
   522 		else 
   517 			{
 
   523 			{
 
   518 			profileReq99.iContextName.Copy(contextName);
 
   524 			profileReq99.iContextName.Copy(contextName);
 
   519 			if (profileReq99.iContextName.Match(iPacketContext->ContextName())==KErrNotFound)
 
   525 			if (profileReq99.iContextName.Match(iPacketContext->ContextName())==KErrNotFound)
 
   520 				{
 
   526 				{
 
   521 				LOGPARSERR("QosProfileReqR99::contextName",KErrArgument,0,&KQosProfileReqR99);
 
   527 				OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_2, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::CONTEXTNAME returned %d (element no. %d) from tag %s.",KErrArgument,0,KQosProfileReqR99);
 
   522 				continue;
 
   528 				continue;
 
   523 				}
 
   529 				}
 
   524 			}
 
   530 			}
 
   525 
   531 
   526 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,reqTraffic);
 
   532 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,reqTraffic);
 
   527 		if(ret!=KErrNone)
 
   533 		if(ret!=KErrNone)
 
   528 			{
 
   534 			{
 
   529 			LOGPARSERR("QosProfileReqR99::reqTraffic",ret,1,&KQosProfileReqR99);
 
   535 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_3, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::REQTRAFFIC returned %d (element no. %d) from tag %s.",ret,1,KQosProfileReqR99);
 
   530 			continue;
 
   536 			continue;
 
   531 			}
 
   537 			}
 
   532 		else 
   538 		else 
   533 			{
 
   539 			{
 
   534 			if(AsciiToNum(reqTraffic, digit)==KErrNone)
 
   540 			if(AsciiToNum(reqTraffic, digit)==KErrNone)
 
   538 			}
 
   544 			}
 
   539 
   545 
   540 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,minTraffic);
 
   546 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,minTraffic);
 
   541 		if(ret!=KErrNone)
 
   547 		if(ret!=KErrNone)
 
   542 			{
 
   548 			{
 
   543 			LOGPARSERR("QosProfileReqR99::minTraffic",ret,2,&KQosProfileReqR99);
 
   549 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_4, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::MINTRAFFIC returned %d (element no. %d) from tag %s.",ret,2,KQosProfileReqR99);
 
   544 			continue;
 
   550 			continue;
 
   545 			}
 
   551 			}
 
   546 		else 
   552 		else 
   547 			{
 
   553 			{
 
   548 			if(AsciiToNum(minTraffic, digit)==KErrNone)
 
   554 			if(AsciiToNum(minTraffic, digit)==KErrNone)
 
   552 			}
 
   558 			}
 
   553 
   559 
   554 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,reqDeliveryOrder);
 
   560 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,reqDeliveryOrder);
 
   555 		if(ret!=KErrNone)
 
   561 		if(ret!=KErrNone)
 
   556 			{
 
   562 			{
 
   557 			LOGPARSERR("QosProfileReqR99::reqDeliveryOrder",ret,3,&KQosProfileReqR99);
 
   563 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_5, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::REQDELIVERYORDER returned %d (element no. %d) from tag %s.",ret,3,KQosProfileReqR99);
 
   558 			continue;
 
   564 			continue;
 
   559 			}
 
   565 			}
 
   560 		else 
   566 		else 
   561 			{
 
   567 			{
 
   562 			if(AsciiToNum(reqDeliveryOrder, digit)==KErrNone)
 
   568 			if(AsciiToNum(reqDeliveryOrder, digit)==KErrNone)
 
   566 			}
 
   572 			}
 
   567 
   573 
   568 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,minDeliveryOrder);
 
   574 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,minDeliveryOrder);
 
   569 		if(ret!=KErrNone)
 
   575 		if(ret!=KErrNone)
 
   570 			{
 
   576 			{
 
   571 			LOGPARSERR("QosProfileReqR99::minDeliveryOrder",ret,4,&KQosProfileReqR99);
 
   577 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_6, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::MINDELIVERYORDER returned %d (element no. %d) from tag %s.",ret,4,KQosProfileReqR99);
 
   572 			continue;
 
   578 			continue;
 
   573 			}
 
   579 			}
 
   574 		else 
   580 		else 
   575 			{
 
   581 			{
 
   576 			if(AsciiToNum(minDeliveryOrder, digit)==KErrNone)
 
   582 			if(AsciiToNum(minDeliveryOrder, digit)==KErrNone)
 
   580 			}
 
   586 			}
 
   581 
   587 
   582 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,reqErroneousSDU);
 
   588 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,reqErroneousSDU);
 
   583 		if(ret!=KErrNone)
 
   589 		if(ret!=KErrNone)
 
   584 			{
 
   590 			{
 
   585 			LOGPARSERR("QosProfileReqR99::reqErroneousSDU",ret,5,&KQosProfileReqR99);
 
   591 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_7, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::REQERRONEOUSSDU returned %d (element no. %d) from tag %s.",ret,5,KQosProfileReqR99);
 
   586 			continue;
 
   592 			continue;
 
   587 			}
 
   593 			}
 
   588 		else 
   594 		else 
   589 			{
 
   595 			{
 
   590 			if(AsciiToNum(reqErroneousSDU, digit)==KErrNone)
 
   596 			if(AsciiToNum(reqErroneousSDU, digit)==KErrNone)
 
   594 			}
 
   600 			}
 
   595 
   601 
   596 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,minErroneousSDU);
 
   602 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,minErroneousSDU);
 
   597 		if(ret!=KErrNone)
 
   603 		if(ret!=KErrNone)
 
   598 			{
 
   604 			{
 
   599 			LOGPARSERR("QosProfileReqR99::minErroneousSDU",ret,6,&KQosProfileReqR99);
 
   605 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_8, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::MINERRONEOUSSDU returned %d (element no. %d) from tag %s.",ret,6,KQosProfileReqR99);
 
   600 			continue;
 
   606 			continue;
 
   601 			}
 
   607 			}
 
   602 		else 
   608 		else 
   603 			{
 
   609 			{
 
   604 			if(AsciiToNum(minErroneousSDU, digit)==KErrNone)
 
   610 			if(AsciiToNum(minErroneousSDU, digit)==KErrNone)
 
   608 			}
 
   614 			}
 
   609 
   615 
   610 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,maxSDUSize);
 
   616 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,maxSDUSize);
 
   611 		if(ret!=KErrNone)
 
   617 		if(ret!=KErrNone)
 
   612 			{
 
   618 			{
 
   613 			LOGPARSERR("QosProfileReqR99::maxSDUSize",ret,7,&KQosProfileReqR99);
 
   619 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_9, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::MAXSDUSIZE returned %d (element no. %d) from tag %s.",ret,7,KQosProfileReqR99);
 
   614 			continue;
 
   620 			continue;
 
   615 			}
 
   621 			}
 
   616 		else 
   622 		else 
   617 			{
 
   623 			{
 
   618 			profileReq99.iMaxSDUSize=maxSDUSize;
 
   624 			profileReq99.iMaxSDUSize=maxSDUSize;
 
   619 			}
 
   625 			}
 
   620 
   626 
   621 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,minSDUSize);
 
   627 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,minSDUSize);
 
   622 		if(ret!=KErrNone)
 
   628 		if(ret!=KErrNone)
 
   623 			{
 
   629 			{
 
   624 			LOGPARSERR("QosProfileReqR99::minSDUSize",ret,8,&KQosProfileReqR99);
 
   630 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_10, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::MINSDUSIZE returned %d (element no. %d) from tag %s.",ret,8,KQosProfileReqR99);
 
   625 			continue;
 
   631 			continue;
 
   626 			}
 
   632 			}
 
   627 		else 
   633 		else 
   628 			{
 
   634 			{
 
   629 			profileReq99.iMinSDUSize=minSDUSize;
 
   635 			profileReq99.iMinSDUSize=minSDUSize;
 
   630 			}
 
   636 			}
 
   631 
   637 
   632 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,reqUpLinkBitRate);
 
   638 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,reqUpLinkBitRate);
 
   633 		if(ret!=KErrNone)
 
   639 		if(ret!=KErrNone)
 
   634 			{
 
   640 			{
 
   635 			LOGPARSERR("QosProfileReqR99::reqUpLinkBitRate",ret,9,&KQosProfileReqR99);
 
   641 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_11, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::REQUPLINKBITRATE returned %d (element no. %d) from tag %s.",ret,9,KQosProfileReqR99);
 
   636 			continue;
 
   642 			continue;
 
   637 			}
 
   643 			}
 
   638 		else 
   644 		else 
   639 			{
 
   645 			{
 
   640 			profileReq99.iReqUpLinkTBitRate=reqUpLinkBitRate;
 
   646 			profileReq99.iReqUpLinkTBitRate=reqUpLinkBitRate;
 
   641 			}
 
   647 			}
 
   642 
   648 
   643 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,reqDownLinkBitRate);
 
   649 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,reqDownLinkBitRate);
 
   644 		if(ret!=KErrNone)
 
   650 		if(ret!=KErrNone)
 
   645 			{
 
   651 			{
 
   646 			LOGPARSERR("QosProfileReqR99::reqDownLinkBitRate",ret,10,&KQosProfileReqR99);
 
   652 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_12, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::REQDOWNLINKBITRATE returned %d (element no. %d) from tag %s.",ret,10,KQosProfileReqR99);
 
   647 			continue;
 
   653 			continue;
 
   648 			}
 
   654 			}
 
   649 		else 
   655 		else 
   650 			{
 
   656 			{
 
   651 			profileReq99.iReqDownLinkTBitRate= reqDownLinkBitRate;
 
   657 			profileReq99.iReqDownLinkTBitRate= reqDownLinkBitRate;
 
   652 			}
 
   658 			}
 
   653 
   659 
   654 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,minUpLinkBitRate);
 
   660 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,minUpLinkBitRate);
 
   655 		if(ret!=KErrNone)
 
   661 		if(ret!=KErrNone)
 
   656 			{
 
   662 			{
 
   657 			LOGPARSERR("QosProfileReqR99::minUpLinkBitRate",ret,11,&KQosProfileReqR99);
 
   663 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_13, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::MINUPLINKBITRATE returned %d (element no. %d) from tag %s.",ret,11,KQosProfileReqR99);
 
   658 			continue;
 
   664 			continue;
 
   659 			}
 
   665 			}
 
   660 		else 
   666 		else 
   661 			{
 
   667 			{
 
   662 			profileReq99.iMinUpLinkTBitRate= minUpLinkBitRate;
 
   668 			profileReq99.iMinUpLinkTBitRate= minUpLinkBitRate;
 
   673 			}
 
   679 			}
 
   674 
   680 
   675 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,13,reqBitErrorRatio);
 
   681 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,13,reqBitErrorRatio);
 
   676 		if(ret!=KErrNone)
 
   682 		if(ret!=KErrNone)
 
   677 			{
 
   683 			{
 
   678 			LOGPARSERR("QosProfileReqR99::reqBitErrorRatio",ret,13,&KQosProfileReqR99);
 
   684 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_14, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::REQBITERRORRATIO returned %d (element no. %d) from tag %s.",ret,13,KQosProfileReqR99);
 
   679 			continue;
 
   685 			continue;
 
   680 			}
 
   686 			}
 
   681 		else 
   687 		else 
   682 			{
 
   688 			{
 
   683 			if(AsciiToNum(reqBitErrorRatio, digit)==KErrNone)
 
   689 			if(AsciiToNum(reqBitErrorRatio, digit)==KErrNone)
 
   687 			}
 
   693 			}
 
   688 
   694 
   689 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,14,minBitErrorRatio);
 
   695 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,14,minBitErrorRatio);
 
   690 		if(ret!=KErrNone)
 
   696 		if(ret!=KErrNone)
 
   691 			{
 
   697 			{
 
   692 			LOGPARSERR("QosProfileReqR99::minBitErrorRatio",ret,14,&KQosProfileReqR99);
 
   698 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_15, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::MINBITERRORRATIO returned %d (element no. %d) from tag %s.",ret,14,KQosProfileReqR99);
 
   693 			continue;
 
   699 			continue;
 
   694 			}
 
   700 			}
 
   695 		else 
   701 		else 
   696 			{
 
   702 			{
 
   697 			if(AsciiToNum(minBitErrorRatio, digit)==KErrNone)
 
   703 			if(AsciiToNum(minBitErrorRatio, digit)==KErrNone)
 
   701 			}
 
   707 			}
 
   702 
   708 
   703 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,15,reqSDUErrorRatio);
 
   709 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,15,reqSDUErrorRatio);
 
   704 		if(ret!=KErrNone)
 
   710 		if(ret!=KErrNone)
 
   705 			{
 
   711 			{
 
   706 			LOGPARSERR("- QosProfileReqR99::reqSDUErrorRatio",ret,15,&KQosProfileReqR99);
 
   712 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_16, "WARNING - CONFIGURATION FILE PARSING - Reading element - QOSPROFILEREQR99::REQSDUERRORRATIO returned %d (element no. %d) from tag %s.",ret,15,KQosProfileReqR99);
 
   707 			continue;
 
   713 			continue;
 
   708 			}
 
   714 			}
 
   709 		else 
   715 		else 
   710 			{
 
   716 			{
 
   711 			if(AsciiToNum(reqSDUErrorRatio, digit)==KErrNone)
 
   717 			if(AsciiToNum(reqSDUErrorRatio, digit)==KErrNone)
 
   715 			}
 
   721 			}
 
   716 
   722 
   717 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,16,minSDUErrorRatio);
 
   723 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,16,minSDUErrorRatio);
 
   718 		if(ret!=KErrNone)
 
   724 		if(ret!=KErrNone)
 
   719 			{
 
   725 			{
 
   720 			LOGPARSERR("- QosProfileReqR99::minSDUErrorRatio",ret,16,&KQosProfileReqR99);
 
   726 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_17, "WARNING - CONFIGURATION FILE PARSING - Reading element - QOSPROFILEREQR99::MINSDUERRORRATIO returned %d (element no. %d) from tag %s.",ret,16,KQosProfileReqR99);
 
   721 			continue;
 
   727 			continue;
 
   722 			}
 
   728 			}
 
   723 		else 
   729 		else 
   724 			{
 
   730 			{
 
   725 			if(AsciiToNum(minSDUErrorRatio, digit)==KErrNone)
 
   731 			if(AsciiToNum(minSDUErrorRatio, digit)==KErrNone)
 
   729 			}
 
   735 			}
 
   730 
   736 
   731 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,17,reqTrafficHandlingPriority);
 
   737 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,17,reqTrafficHandlingPriority);
 
   732 		if(ret!=KErrNone)
 
   738 		if(ret!=KErrNone)
 
   733 			{
 
   739 			{
 
   734 			LOGPARSERR("QosProfileReqR99::reqTrafficHandlingPriority",ret,17,&KQosProfileReqR99);
 
   740 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_18, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::REQTRAFFICHANDLINGPRIORITY returned %d (element no. %d) from tag %s.",ret,17,KQosProfileReqR99);
 
   735 			continue;
 
   741 			continue;
 
   736 			}
 
   742 			}
 
   737 		else 
   743 		else 
   738 			{
 
   744 			{
 
   739 			if(AsciiToNum(reqTrafficHandlingPriority, digit)==KErrNone)
 
   745 			if(AsciiToNum(reqTrafficHandlingPriority, digit)==KErrNone)
 
   743 			}
 
   749 			}
 
   744 
   750 
   745 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,18,minTrafficHandlingPriority);
 
   751 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,18,minTrafficHandlingPriority);
 
   746 		if(ret!=KErrNone)
 
   752 		if(ret!=KErrNone)
 
   747 			{
 
   753 			{
 
   748 			LOGPARSERR("QosProfileReqR99::minTrafficHandlingPriority",ret,18,&KQosProfileReqR99);
 
   754 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_19, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::MINTRAFFICHANDLINGPRIORITY returned %d (element no. %d) from tag %s.",ret,18,KQosProfileReqR99);
 
   749 			continue;
 
   755 			continue;
 
   750 			}
 
   756 			}
 
   751 		else 
   757 		else 
   752 			{
 
   758 			{
 
   753 			if(AsciiToNum(minTrafficHandlingPriority, digit)==KErrNone)
 
   759 			if(AsciiToNum(minTrafficHandlingPriority, digit)==KErrNone)
 
   757 			}
 
   763 			}
 
   758 
   764 
   759 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,19,reqTransferDelay);
 
   765 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,19,reqTransferDelay);
 
   760 		if(ret!=KErrNone)
 
   766 		if(ret!=KErrNone)
 
   761 			{
 
   767 			{
 
   762 			LOGPARSERR("QosProfileReqR99::reqTransferDelay",ret,19,&KQosProfileReqR99);
 
   768 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_20, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::REQTRANSFERDELAY returned %d (element no. %d) from tag %s.",ret,19,KQosProfileReqR99);
 
   763 			continue;
 
   769 			continue;
 
   764 			}
 
   770 			}
 
   765 		else 
   771 		else 
   766 			{
 
   772 			{
 
   767 			profileReq99.iReqTransferDelay= reqTransferDelay;
 
   773 			profileReq99.iReqTransferDelay= reqTransferDelay;
 
   768 			}
 
   774 			}
 
   769 
   775 
   770 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,20,minTransferDelay);
 
   776 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,20,minTransferDelay);
 
   771 		if(ret!=KErrNone)
 
   777 		if(ret!=KErrNone)
 
   772 			{
 
   778 			{
 
   773 			LOGPARSERR("QosProfileReqR99::minTransferDelay",ret,20,&KQosProfileReqR99);
 
   779 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_21, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::MINTRANSFERDELAY returned %d (element no. %d) from tag %s.",ret,20,KQosProfileReqR99);
 
   774 			continue;
 
   780 			continue;
 
   775 			}
 
   781 			}
 
   776 		else 
   782 		else 
   777 			{
 
   783 			{
 
   778 			profileReq99.iMinTransferDelay= minTransferDelay;
 
   784 			profileReq99.iMinTransferDelay= minTransferDelay;
 
   779 			}
 
   785 			}
 
   780 
   786 
   781 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,21,reqGuaranteedUpLinkBitRate);
 
   787 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,21,reqGuaranteedUpLinkBitRate);
 
   782 		if(ret!=KErrNone)
 
   788 		if(ret!=KErrNone)
 
   783 			{
 
   789 			{
 
   784 			LOGPARSERR("QosProfileReqR99::reqGuaranteedUpLinkBitRate",ret,21,&KQosProfileReqR99);
 
   790 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_22, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::REQGUARANTEEDUPLINKBITRATE returned %d (element no. %d) from tag %s.",ret,21,KQosProfileReqR99);
 
   785 			continue;
 
   791 			continue;
 
   786 			}
 
   792 			}
 
   787 		else 
   793 		else 
   788 			{
 
   794 			{
 
   789 			profileReq99.iReqGuaranteedUpLinkTBitRate= reqGuaranteedUpLinkBitRate;
 
   795 			profileReq99.iReqGuaranteedUpLinkTBitRate= reqGuaranteedUpLinkBitRate;
 
   790 			}
 
   796 			}
 
   791 
   797 
   792 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,22,reqGuaranteedDownLinkBitRate);
 
   798 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,22,reqGuaranteedDownLinkBitRate);
 
   793 		if(ret!=KErrNone)
 
   799 		if(ret!=KErrNone)
 
   794 			{
 
   800 			{
 
   795 			LOGPARSERR("QosProfileReqR99::reqGuaranteedDownLinkBitRate",ret,22,&KQosProfileReqR99);
 
   801 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_23, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::REQGUARANTEEDDOWNLINKBITRATE returned %d (element no. %d) from tag %s.",ret,22,KQosProfileReqR99);
 
   796 			continue;
 
   802 			continue;
 
   797 			}
 
   803 			}
 
   798 		else 
   804 		else 
   799 			{
 
   805 			{
 
   800 			profileReq99.iReqGuaranteedDownLinkTBitRate= reqGuaranteedDownLinkBitRate;
 
   806 			profileReq99.iReqGuaranteedDownLinkTBitRate= reqGuaranteedDownLinkBitRate;
 
   801 			}
 
   807 			}
 
   802 
   808 
   803 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,23,minGuaranteedUpLinkBitRate);
 
   809 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,23,minGuaranteedUpLinkBitRate);
 
   804 		if(ret!=KErrNone)
 
   810 		if(ret!=KErrNone)
 
   805 			{
 
   811 			{
 
   806 			LOGPARSERR("QosProfileReqR99::minGuaranteedUpLinkBitRate",ret,23,&KQosProfileReqR99);
 
   812 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_24, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::MINGUARANTEEDUPLINKBITRATE returned %d (element no. %d) from tag %s.",ret,23,KQosProfileReqR99);
 
   807 			continue;
 
   813 			continue;
 
   808 			}
 
   814 			}
 
   809 		else 
   815 		else 
   810 			{
 
   816 			{
 
   811 			profileReq99.iMinGuaranteedUpLinkTBitRate= minGuaranteedUpLinkBitRate;
 
   817 			profileReq99.iMinGuaranteedUpLinkTBitRate= minGuaranteedUpLinkBitRate;
 
   812 			}
 
   818 			}
 
   813 
   819 
   814 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,24,minGuaranteedDownLinkBitRate);
 
   820 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,24,minGuaranteedDownLinkBitRate);
 
   815 		if(ret!=KErrNone)
 
   821 		if(ret!=KErrNone)
 
   816 			{
 
   822 			{
 
   817 			LOGPARSERR("QosProfileReqR99::minGuaranteedDownLinkBitRate",ret,24,&KQosProfileReqR99);
 
   823 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99REQPROFILESL_25, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR99::MINGUARANTEEDDOWNLINKBITRATE returned %d (element no. %d) from tag %s.",ret,24,KQosProfileReqR99);
 
   818 			continue;
 
   824 			continue;
 
   819 			}
 
   825 			}
 
   820 		else 
   826 		else 
   821 			{
 
   827 			{
 
   822 			profileReq99.iMinGuaranteedDownLinkTBitRate= minGuaranteedDownLinkBitRate;
 
   828 			profileReq99.iMinGuaranteedDownLinkTBitRate= minGuaranteedDownLinkBitRate;
 
   847 		TInt negMaxUpLinkRate, negMaxDownLinkRate, negMaxSDUSize;
 
   853 		TInt negMaxUpLinkRate, negMaxDownLinkRate, negMaxSDUSize;
 
   848 		 
   854 		 
   849 		TInt ret = CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextName);
 
   855 		TInt ret = CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextName);
 
   850 		if(ret!=KErrNone)
 
   856 		if(ret!=KErrNone)
 
   851 			{
 
   857 			{
 
   852 			LOGPARSERR("QosProfileNegR99::contextName",ret,0,&KQosProfileNegR99);
 
   858 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NEGPROFILESL_1, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR99::CONTEXTNAME returned %d (element no. %d) from tag %s.",ret,0,KQosProfileNegR99);
 
   853 			continue;
 
   859 			continue;
 
   854 			}
 
   860 			}
 
   855 		else
 
   861 		else
 
   856 			{
 
   862 			{
 
   857 			profileNeg99.iContextName.Copy(contextName);
 
   863 			profileNeg99.iContextName.Copy(contextName);
 
   858 			if (profileNeg99.iContextName.Match(iPacketContext->ContextName())==KErrNotFound)
 
   864 			if (profileNeg99.iContextName.Match(iPacketContext->ContextName())==KErrNotFound)
 
   859 				{
 
   865 				{
 
   860 				LOGPARSERR("QosProfileNegR99::contextName",KErrArgument,0,&KQosProfileNegR99);
 
   866 				OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NEGPROFILESL_2, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR99::CONTEXTNAME returned %d (element no. %d) from tag %s.",KErrArgument,0,KQosProfileNegR99);
 
   861 				continue;
 
   867 				continue;
 
   862 				}
 
   868 				}
 
   863 			}
 
   869 			}
 
   864 
   870 
   865 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,duration);
 
   871 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,duration);
 
   866 		if(ret!=KErrNone)
 
   872 		if(ret!=KErrNone)
 
   867 			{
 
   873 			{
 
   868 			LOGPARSERR("QosProfileNegR99::duration",ret,1,&KQosProfileNegR99);
 
   874 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NEGPROFILESL_3, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR99::DURATION returned %d (element no. %d) from tag %s.",ret,1,KQosProfileNegR99);
 
   869 			continue;
 
   875 			continue;
 
   870 			}
 
   876 			}
 
   871 		else
 
   877 		else
 
   872 			{
 
   878 			{
 
   873 			if(AsciiToNum(duration, digit)==KErrNone)
 
   879 			if(AsciiToNum(duration, digit)==KErrNone)
 
   875 			}
 
   881 			}
 
   876 
   882 
   877 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,negTraffic);
 
   883 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,negTraffic);
 
   878 		if(ret!=KErrNone)
 
   884 		if(ret!=KErrNone)
 
   879 			{
 
   885 			{
 
   880 			LOGPARSERR("QosProfileNegR99::negTraffic",ret,2,&KQosProfileNegR99);
 
   886 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NEGPROFILESL_4, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR99::NEGTRAFFIC returned %d (element no. %d) from tag %s.",ret,2,KQosProfileNegR99);
 
   881 			continue;
 
   887 			continue;
 
   882 			}
 
   888 			}
 
   883 		else
 
   889 		else
 
   884 			{
 
   890 			{
 
   885 			if(AsciiToNum(negTraffic, digit)==KErrNone)
 
   891 			if(AsciiToNum(negTraffic, digit)==KErrNone)
 
   887 			}
 
   893 			}
 
   888 
   894 
   889 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,negDeliveryOrder);
 
   895 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,negDeliveryOrder);
 
   890 		if(ret!=KErrNone)
 
   896 		if(ret!=KErrNone)
 
   891 			{
 
   897 			{
 
   892 			LOGPARSERR("QosProfileNegR99::negDeliveryOrder",ret,3,&KQosProfileNegR99);
 
   898 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NEGPROFILESL_5, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR99::NEGDELIVERYORDER returned %d (element no. %d) from tag %s.",ret,3,KQosProfileNegR99);
 
   893 			continue;
 
   899 			continue;
 
   894 			}
 
   900 			}
 
   895 		else
 
   901 		else
 
   896 			{
 
   902 			{
 
   897 			if(AsciiToNum(negDeliveryOrder, digit)==KErrNone)
 
   903 			if(AsciiToNum(negDeliveryOrder, digit)==KErrNone)
 
   899 			}
 
   905 			}
 
   900 
   906 
   901 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,negErroneousSDUDelivery);
 
   907 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,negErroneousSDUDelivery);
 
   902 		if(ret!=KErrNone)
 
   908 		if(ret!=KErrNone)
 
   903 			{
 
   909 			{
 
   904 			LOGPARSERR("QosProfileNegR99::negErroneousSDUDelivery",ret,4,&KQosProfileNegR99);
 
   910 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NEGPROFILESL_6, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR99::NEGERRONEOUSSDUDELIVERY returned %d (element no. %d) from tag %s.",ret,4,KQosProfileNegR99);
 
   905 			continue;
 
   911 			continue;
 
   906 			}
 
   912 			}
 
   907 		else
 
   913 		else
 
   908 			{
 
   914 			{
 
   909 			if(AsciiToNum(negErroneousSDUDelivery, digit)==KErrNone)
 
   915 			if(AsciiToNum(negErroneousSDUDelivery, digit)==KErrNone)
 
   911 			}
 
   917 			}
 
   912 
   918 
   913 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,negMaxSDUSize);
 
   919 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,negMaxSDUSize);
 
   914 		if(ret!=KErrNone)
 
   920 		if(ret!=KErrNone)
 
   915 			{
 
   921 			{
 
   916 			LOGPARSERR("QosProfileNegR99::negMaxSDUSize",ret,5,&KQosProfileNegR99);
 
   922 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NEGPROFILESL_7, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR99::NEGMAXSDUSIZE returned %d (element no. %d) from tag %s.",ret,5,KQosProfileNegR99);
 
   917 			continue;
 
   923 			continue;
 
   918 			}
 
   924 			}
 
   919 		else
 
   925 		else
 
   920 			{
 
   926 			{
 
   921 			profileNeg99.iNegMaxSDUSize =  negMaxSDUSize;
 
   927 			profileNeg99.iNegMaxSDUSize =  negMaxSDUSize;
 
   922 			}
 
   928 			}
 
   923 
   929 
   924 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,negBitErrorRatio);
 
   930 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,negBitErrorRatio);
 
   925 		if(ret!=KErrNone)
 
   931 		if(ret!=KErrNone)
 
   926 			{
 
   932 			{
 
   927 			LOGPARSERR("QosProfileNegR99::negBitErrorRatio",ret,6,&KQosProfileNegR99);
 
   933 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NEGPROFILESL_8, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR99::NEGBITERRORRATIO returned %d (element no. %d) from tag %s.",ret,6,KQosProfileNegR99);
 
   928 			continue;
 
   934 			continue;
 
   929 			}
 
   935 			}
 
   930 		else
 
   936 		else
 
   931 			{
 
   937 			{
 
   932 			if(AsciiToNum(negBitErrorRatio, digit)==KErrNone)
 
   938 			if(AsciiToNum(negBitErrorRatio, digit)==KErrNone)
 
   935 
   941 
   936 		
   942 		
   937 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,negSDUErrorRatio);
 
   943 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,negSDUErrorRatio);
 
   938 		if(ret!=KErrNone)
 
   944 		if(ret!=KErrNone)
 
   939 			{
 
   945 			{
 
   940 			LOGPARSERR("QosProfileNegR99::negSDUErrorRatio",ret,7,&KQosProfileNegR99);
 
   946 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NEGPROFILESL_9, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR99::NEGSDUERRORRATIO returned %d (element no. %d) from tag %s.",ret,7,KQosProfileNegR99);
 
   941 			continue;
 
   947 			continue;
 
   942 			}
 
   948 			}
 
   943 		else
 
   949 		else
 
   944 			{
 
   950 			{
 
   945 			if(AsciiToNum(negSDUErrorRatio, digit)==KErrNone)
 
   951 			if(AsciiToNum(negSDUErrorRatio, digit)==KErrNone)
 
   947 			}
 
   953 			}
 
   948 
   954 
   949 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,negTrafficHandlingPriority);
 
   955 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,negTrafficHandlingPriority);
 
   950 		if(ret!=KErrNone)
 
   956 		if(ret!=KErrNone)
 
   951 			{
 
   957 			{
 
   952 			LOGPARSERR("QosProfileNegR99::negTrafficHandlingPriority",ret,8,&KQosProfileNegR99);
 
   958 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NEGPROFILESL_10, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR99::NEGTRAFFICHANDLINGPRIORITY returned %d (element no. %d) from tag %s.",ret,8,KQosProfileNegR99);
 
   953 			continue;
 
   959 			continue;
 
   954 			}
 
   960 			}
 
   955 		else
 
   961 		else
 
   956 			{
 
   962 			{
 
   957 			if(AsciiToNum(negTrafficHandlingPriority, digit)==KErrNone)
 
   963 			if(AsciiToNum(negTrafficHandlingPriority, digit)==KErrNone)
 
   959 			}
 
   965 			}
 
   960 
   966 
   961 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,negTransferDelay);
 
   967 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,negTransferDelay);
 
   962 		if(ret!=KErrNone)
 
   968 		if(ret!=KErrNone)
 
   963 			{
 
   969 			{
 
   964 			LOGPARSERR("QosProfileNegR99::negTransferDelay",ret,9,&KQosProfileNegR99);
 
   970 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NEGPROFILESL_11, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR99::NEGTRANSFERDELAY returned %d (element no. %d) from tag %s.",ret,9,KQosProfileNegR99);
 
   965 			continue;
 
   971 			continue;
 
   966 			}
 
   972 			}
 
   967 		else
 
   973 		else
 
   968 			{
 
   974 			{
 
   969 			profileNeg99.iNegTransferDelay =  negTransferDelay;
 
   975 			profileNeg99.iNegTransferDelay =  negTransferDelay;
 
   970 			}
 
   976 			}
 
   971 
   977 
   972 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,negGuaranteedUpLinkBitRate);
 
   978 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,negGuaranteedUpLinkBitRate);
 
   973 		if(ret!=KErrNone)
 
   979 		if(ret!=KErrNone)
 
   974 			{
 
   980 			{
 
   975 			LOGPARSERR("QosProfileNegR99::negGuaranteedUpLinkBitRate",ret,10,&KQosProfileNegR99);
 
   981 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NEGPROFILESL_12, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR99::NEGGUARANTEEDUPLINKBITRATE returned %d (element no. %d) from tag %s.",ret,10,KQosProfileNegR99);
 
   976 			continue;
 
   982 			continue;
 
   977 			}
 
   983 			}
 
   978 		else
 
   984 		else
 
   979 			{
 
   985 			{
 
   980 			profileNeg99.iNegGuaranteedUpLinkBitRate =  negGuaranteedUpLinkBitRate;
 
   986 			profileNeg99.iNegGuaranteedUpLinkBitRate =  negGuaranteedUpLinkBitRate;
 
   981 			}
 
   987 			}
 
   982 
   988 
   983 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,negGuaranteedDownLinkBitRate);
 
   989 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,negGuaranteedDownLinkBitRate);
 
   984 		if(ret!=KErrNone)
 
   990 		if(ret!=KErrNone)
 
   985 			{
 
   991 			{
 
   986 			LOGPARSERR("QosProfileNegR99::negGuaranteedDownLinkBitRate",ret,11,&KQosProfileNegR99);
 
   992 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NEGPROFILESL_13, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR99::NEGGUARANTEEDDOWNLINKBITRATE returned %d (element no. %d) from tag %s.",ret,11,KQosProfileNegR99);
 
   987 			continue;
 
   993 			continue;
 
   988 			}
 
   994 			}
 
   989 		else
 
   995 		else
 
   990 			{
 
   996 			{
 
   991 			profileNeg99.iNegGuaranteedDownLinkBitRate =  negGuaranteedDownLinkBitRate;
 
   997 			profileNeg99.iNegGuaranteedDownLinkBitRate =  negGuaranteedDownLinkBitRate;
 
   992 			}
 
   998 			}
 
   993 
   999 
   994 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,12,negMaxUpLinkRate);
 
  1000 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,12,negMaxUpLinkRate);
 
   995 		if(ret!=KErrNone)
 
  1001 		if(ret!=KErrNone)
 
   996 			{
 
  1002 			{
 
   997 			LOGPARSERR("QosProfileNegR99::negMaxUpLinkRate",ret,12,&KQosProfileNegR99);
 
  1003 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NEGPROFILESL_14, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR99::NEGMAXUPLINKRATE returned %d (element no. %d) from tag %s.",ret,12,KQosProfileNegR99);
 
   998 			continue;
 
  1004 			continue;
 
   999 			}
 
  1005 			}
 
  1000 		else
 
  1006 		else
 
  1001 			{
 
  1007 			{
 
  1002 			profileNeg99.iNegMaxUpLinkRate =  negMaxUpLinkRate;
 
  1008 			profileNeg99.iNegMaxUpLinkRate =  negMaxUpLinkRate;
 
  1003 			}
 
  1009 			}
 
  1004 
  1010 
  1005 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,13,negMaxDownLinkRate);
 
  1011 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,13,negMaxDownLinkRate);
 
  1006 		if(ret!=KErrNone)
 
  1012 		if(ret!=KErrNone)
 
  1007 			{
 
  1013 			{
 
  1008 			LOGPARSERR("QosProfileNegR99::negMaxDownLinkRate",ret,13,&KQosProfileNegR99);
 
  1014 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NEGPROFILESL_15, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR99::NEGMAXDOWNLINKRATE returned %d (element no. %d) from tag %s.",ret,13,KQosProfileNegR99);
 
  1009 			continue;
 
  1015 			continue;
 
  1010 			}
 
  1016 			}
 
  1011 		else
 
  1017 		else
 
  1012 			{
 
  1018 			{
 
  1013 			profileNeg99.iNegMaxDownLinkRate =  negMaxDownLinkRate;
 
  1019 			profileNeg99.iNegMaxDownLinkRate =  negMaxDownLinkRate;
 
  1051 		TInt negMaxUpLinkRate, negMaxDownLinkRate, negMaxSDUSize;
 
  1057 		TInt negMaxUpLinkRate, negMaxDownLinkRate, negMaxSDUSize;
 
  1052 
  1058 
  1053 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextName);
 
  1059 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextName);
 
  1054 		if(ret!=KErrNone)
 
  1060 		if(ret!=KErrNone)
 
  1055 			{
 
  1061 			{
 
  1056 			LOGPARSERR("QosNetworkNotification::contextName",ret,0,&KQosNetworkNotificationType);
 
  1062 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NETWORKNOTIFICATIONSL_1, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSNETWORKNOTIFICATION::CONTEXTNAME returned %d (element no. %d) from tag %s.",ret,0,KQosNetworkNotificationType);
 
  1057 			continue;
 
  1063 			continue;
 
  1058 			}
 
  1064 			}
 
  1059 		else
 
  1065 		else
 
  1060 			{
 
  1066 			{
 
  1061 			qosNetworkNotification.iContextName.Copy(contextName);
 
  1067 			qosNetworkNotification.iContextName.Copy(contextName);
 
  1062 			}
 
  1068 			}
 
  1063 
  1069 
  1064 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,duration);
 
  1070 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,duration);
 
  1065 		if(ret!=KErrNone)
 
  1071 		if(ret!=KErrNone)
 
  1066 			{
 
  1072 			{
 
  1067 			LOGPARSERR("QosNetworkNotification::duration",ret,1,&KQosNetworkNotificationType);
 
  1073 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NETWORKNOTIFICATIONSL_2, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSNETWORKNOTIFICATION::DURATION returned %d (element no. %d) from tag %s.",ret,1,KQosNetworkNotificationType);
 
  1068 			continue;
 
  1074 			continue;
 
  1069 			}
 
  1075 			}
 
  1070 		else
 
  1076 		else
 
  1071 			{
 
  1077 			{
 
  1072 			if(AsciiToNum(duration, digit)==KErrNone)
 
  1078 			if(AsciiToNum(duration, digit)==KErrNone)
 
  1074 			}
 
  1080 			}
 
  1075 
  1081 
  1076 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,negTraffic);
 
  1082 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,negTraffic);
 
  1077 		if(ret!=KErrNone)
 
  1083 		if(ret!=KErrNone)
 
  1078 			{
 
  1084 			{
 
  1079 			LOGPARSERR("QosNetworkNotification::negTraffic",ret,2,&KQosNetworkNotificationType);
 
  1085 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NETWORKNOTIFICATIONSL_3, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSNETWORKNOTIFICATION::NEGTRAFFIC returned %d (element no. %d) from tag %s.",ret,2,KQosNetworkNotificationType);
 
  1080 			continue;
 
  1086 			continue;
 
  1081 			}
 
  1087 			}
 
  1082 		else
 
  1088 		else
 
  1083 			{
 
  1089 			{
 
  1084 			if(AsciiToNum(negTraffic, digit)==KErrNone)
 
  1090 			if(AsciiToNum(negTraffic, digit)==KErrNone)
 
  1086 			}
 
  1092 			}
 
  1087 
  1093 
  1088 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,negDeliveryOrder);
 
  1094 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,negDeliveryOrder);
 
  1089 		if(ret!=KErrNone)
 
  1095 		if(ret!=KErrNone)
 
  1090 			{
 
  1096 			{
 
  1091 			LOGPARSERR("QosNetworkNotification::negDeliveryOrder",ret,3,&KQosNetworkNotificationType);
 
  1097 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NETWORKNOTIFICATIONSL_4, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSNETWORKNOTIFICATION::NEGDELIVERYORDER returned %d (element no. %d) from tag %s.",ret,3,KQosNetworkNotificationType);
 
  1092 			continue;
 
  1098 			continue;
 
  1093 			}
 
  1099 			}
 
  1094 		else
 
  1100 		else
 
  1095 			{
 
  1101 			{
 
  1096 			if(AsciiToNum(negDeliveryOrder, digit)==KErrNone)
 
  1102 			if(AsciiToNum(negDeliveryOrder, digit)==KErrNone)
 
  1098 			}
 
  1104 			}
 
  1099 
  1105 
  1100 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,negErroneousSDUDelivery);
 
  1106 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,negErroneousSDUDelivery);
 
  1101 		if(ret!=KErrNone)
 
  1107 		if(ret!=KErrNone)
 
  1102 			{
 
  1108 			{
 
  1103 			LOGPARSERR("QosNetworkNotification::negErroneousSDUDelivery",ret,4,&KQosNetworkNotificationType);
 
  1109 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NETWORKNOTIFICATIONSL_5, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSNETWORKNOTIFICATION::NEGERRONEOUSSDUDELIVERY returned %d (element no. %d) from tag %s.",ret,4,KQosNetworkNotificationType);
 
  1104 			continue;
 
  1110 			continue;
 
  1105 			}
 
  1111 			}
 
  1106 		else
 
  1112 		else
 
  1107 			{
 
  1113 			{
 
  1108 			if(AsciiToNum(negErroneousSDUDelivery, digit)==KErrNone)
 
  1114 			if(AsciiToNum(negErroneousSDUDelivery, digit)==KErrNone)
 
  1110 			}
 
  1116 			}
 
  1111 
  1117 
  1112 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,negMaxSDUSize);
 
  1118 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,negMaxSDUSize);
 
  1113 		if(ret!=KErrNone)
 
  1119 		if(ret!=KErrNone)
 
  1114 			{
 
  1120 			{
 
  1115 			LOGPARSERR("QosNetworkNotification::negMaxSDUSize",ret,5,&KQosNetworkNotificationType);
 
  1121 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NETWORKNOTIFICATIONSL_6, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSNETWORKNOTIFICATION::NEGMAXSDUSIZE returned %d (element no. %d) from tag %s.",ret,5,KQosNetworkNotificationType);
 
  1116 			continue;
 
  1122 			continue;
 
  1117 			}
 
  1123 			}
 
  1118 		else
 
  1124 		else
 
  1119 			{
 
  1125 			{
 
  1120 			qosNetworkNotification.iNegMaxSDUSize =  negMaxSDUSize;
 
  1126 			qosNetworkNotification.iNegMaxSDUSize =  negMaxSDUSize;
 
  1121 			}
 
  1127 			}
 
  1122 
  1128 
  1123 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,negBitErrorRatio);
 
  1129 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,negBitErrorRatio);
 
  1124 		if(ret!=KErrNone)
 
  1130 		if(ret!=KErrNone)
 
  1125 			{
 
  1131 			{
 
  1126 			LOGPARSERR("QosNetworkNotification::negBitErrorRatio",ret,6,&KQosNetworkNotificationType);
 
  1132 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NETWORKNOTIFICATIONSL_7, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSNETWORKNOTIFICATION::NEGBITERRORRATIO returned %d (element no. %d) from tag %s.",ret,6,KQosNetworkNotificationType);
 
  1127 			continue;
 
  1133 			continue;
 
  1128 			}
 
  1134 			}
 
  1129 		else
 
  1135 		else
 
  1130 			{
 
  1136 			{
 
  1131 			if(AsciiToNum(negBitErrorRatio, digit)==KErrNone)
 
  1137 			if(AsciiToNum(negBitErrorRatio, digit)==KErrNone)
 
  1133 			}
 
  1139 			}
 
  1134 
  1140 
  1135 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,negSDUErrorRatio);
 
  1141 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,negSDUErrorRatio);
 
  1136 		if(ret!=KErrNone)
 
  1142 		if(ret!=KErrNone)
 
  1137 			{
 
  1143 			{
 
  1138 			LOGPARSERR("QosNetworkNotification::negSDUErrorRatio",ret,7,&KQosNetworkNotificationType);
 
  1144 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NETWORKNOTIFICATIONSL_8, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSNETWORKNOTIFICATION::NEGSDUERRORRATIO returned %d (element no. %d) from tag %s.",ret,7,KQosNetworkNotificationType);
 
  1139 			continue;
 
  1145 			continue;
 
  1140 			}
 
  1146 			}
 
  1141 		else
 
  1147 		else
 
  1142 			{
 
  1148 			{
 
  1143 			if(AsciiToNum(negSDUErrorRatio, digit)==KErrNone)
 
  1149 			if(AsciiToNum(negSDUErrorRatio, digit)==KErrNone)
 
  1145 			}
 
  1151 			}
 
  1146 
  1152 
  1147 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,negTrafficHandlingPriority);
 
  1153 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,negTrafficHandlingPriority);
 
  1148 		if(ret!=KErrNone)
 
  1154 		if(ret!=KErrNone)
 
  1149 			{
 
  1155 			{
 
  1150 			LOGPARSERR("QosNetworkNotification::negTrafficHandlingPriority",ret,8,&KQosNetworkNotificationType);
 
  1156 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NETWORKNOTIFICATIONSL_9, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSNETWORKNOTIFICATION::NEGTRAFFICHANDLINGPRIORITY returned %d (element no. %d) from tag %s.",ret,8,KQosNetworkNotificationType);
 
  1151 			continue;
 
  1157 			continue;
 
  1152 			}
 
  1158 			}
 
  1153 		else
 
  1159 		else
 
  1154 			{
 
  1160 			{
 
  1155 			if(AsciiToNum(negTrafficHandlingPriority, digit)==KErrNone)
 
  1161 			if(AsciiToNum(negTrafficHandlingPriority, digit)==KErrNone)
 
  1157 			}
 
  1163 			}
 
  1158 
  1164 
  1159 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,negTransferDelay);
 
  1165 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,negTransferDelay);
 
  1160 		if(ret!=KErrNone)
 
  1166 		if(ret!=KErrNone)
 
  1161 			{
 
  1167 			{
 
  1162 			LOGPARSERR("QosNetworkNotification::negTransferDelay",ret,9,&KQosNetworkNotificationType);
 
  1168 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NETWORKNOTIFICATIONSL_10, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSNETWORKNOTIFICATION::NEGTRANSFERDELAY returned %d (element no. %d) from tag %s.",ret,9,KQosNetworkNotificationType);
 
  1163 			continue;
 
  1169 			continue;
 
  1164 			}
 
  1170 			}
 
  1165 		else
 
  1171 		else
 
  1166 			{
 
  1172 			{
 
  1167 			qosNetworkNotification.iNegTransferDelay =  negTransferDelay;
 
  1173 			qosNetworkNotification.iNegTransferDelay =  negTransferDelay;
 
  1168 			}
 
  1174 			}
 
  1169 
  1175 
  1170 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,negGuaranteedUpLinkBitRate);
 
  1176 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,negGuaranteedUpLinkBitRate);
 
  1171 		if(ret!=KErrNone)
 
  1177 		if(ret!=KErrNone)
 
  1172 			{
 
  1178 			{
 
  1173 			LOGPARSERR("QosNetworkNotification::negGuaranteedUpLinkBitRate",ret,10,&KQosNetworkNotificationType);
 
  1179 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NETWORKNOTIFICATIONSL_11, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSNETWORKNOTIFICATION::NEGGUARANTEEDUPLINKBITRATE returned %d (element no. %d) from tag %s.",ret,10,KQosNetworkNotificationType);
 
  1174 			continue;
 
  1180 			continue;
 
  1175 			}
 
  1181 			}
 
  1176 		else
 
  1182 		else
 
  1177 			{
 
  1183 			{
 
  1178 			qosNetworkNotification.iNegGuaranteedUpLinkBitRate =  negGuaranteedUpLinkBitRate;
 
  1184 			qosNetworkNotification.iNegGuaranteedUpLinkBitRate =  negGuaranteedUpLinkBitRate;
 
  1179 			}
 
  1185 			}
 
  1180 
  1186 
  1181 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,negGuaranteedDownLinkBitRate);
 
  1187 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,negGuaranteedDownLinkBitRate);
 
  1182 		if(ret!=KErrNone)
 
  1188 		if(ret!=KErrNone)
 
  1183 			{
 
  1189 			{
 
  1184 			LOGPARSERR("QosNetworkNotification::negGuaranteedDownLinkBitRate",ret,11,&KQosNetworkNotificationType);
 
  1190 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NETWORKNOTIFICATIONSL_12, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSNETWORKNOTIFICATION::NEGGUARANTEEDDOWNLINKBITRATE returned %d (element no. %d) from tag %s.",ret,11,KQosNetworkNotificationType);
 
  1185 			continue;
 
  1191 			continue;
 
  1186 			}
 
  1192 			}
 
  1187 		else
 
  1193 		else
 
  1188 			{
 
  1194 			{
 
  1189 			qosNetworkNotification.iNegGuaranteedDownLinkBitRate =  negGuaranteedDownLinkBitRate;
 
  1195 			qosNetworkNotification.iNegGuaranteedDownLinkBitRate =  negGuaranteedDownLinkBitRate;
 
  1190 			}
 
  1196 			}
 
  1191 
  1197 
  1192 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,12,negMaxUpLinkRate);
 
  1198 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,12,negMaxUpLinkRate);
 
  1193 		if(ret!=KErrNone)
 
  1199 		if(ret!=KErrNone)
 
  1194 			{
 
  1200 			{
 
  1195 			LOGPARSERR("QosNetworkNotification::negMaxUpLinkRate",ret,12,&KQosNetworkNotificationType);
 
  1201 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NETWORKNOTIFICATIONSL_13, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSNETWORKNOTIFICATION::NEGMAXUPLINKRATE returned %d (element no. %d) from tag %s.",ret,12,KQosNetworkNotificationType);
 
  1196 			continue;
 
  1202 			continue;
 
  1197 			}
 
  1203 			}
 
  1198 		else
 
  1204 		else
 
  1199 			{
 
  1205 			{
 
  1200 			qosNetworkNotification.iNegMaxUpLinkRate =  negMaxUpLinkRate;
 
  1206 			qosNetworkNotification.iNegMaxUpLinkRate =  negMaxUpLinkRate;
 
  1201 			}
 
  1207 			}
 
  1202 
  1208 
  1203 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,13,negMaxDownLinkRate);
 
  1209 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,13,negMaxDownLinkRate);
 
  1204 		if(ret!=KErrNone)
 
  1210 		if(ret!=KErrNone)
 
  1205 			{
 
  1211 			{
 
  1206 			LOGPARSERR("QosNetworkNotification::negMaxDownLinkRate",ret,13,&KQosNetworkNotificationType);
 
  1212 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99NETWORKNOTIFICATIONSL_14, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSNETWORKNOTIFICATION::NEGMAXDOWNLINKRATE returned %d (element no. %d) from tag %s.",ret,13,KQosNetworkNotificationType);
 
  1207 			continue;
 
  1213 			continue;
 
  1208 			}
 
  1214 			}
 
  1209 		else
 
  1215 		else
 
  1210 			{
 
  1216 			{
 
  1211 			qosNetworkNotification.iNegMaxDownLinkRate = negMaxDownLinkRate;
 
  1217 			qosNetworkNotification.iNegMaxDownLinkRate = negMaxDownLinkRate;
 
  1230 		TPtrC8 BERCap, SDUErrorRatioCap, trafficHandlingPriorityCap;
 
  1236 		TPtrC8 BERCap, SDUErrorRatioCap, trafficHandlingPriorityCap;
 
  1231 
  1237 
  1232 		TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,trafficCap);
 
  1238 		TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,trafficCap);
 
  1233 		if(ret!=KErrNone)
 
  1239 		if(ret!=KErrNone)
 
  1234 			{
 
  1240 			{
 
  1235 			LOGPARSERR("QosProfileCapsR99::trafficCap",ret,0,&KQosProfileCapsR99);
 
  1241 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99QOSPROFILECAPS_1, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSR99::TRAFFICCAP returned %d (element no. %d) from tag %s.",ret,0,KQosProfileCapsR99);
 
  1236 			}
 
  1242 			}
 
  1237 		else
 
  1243 		else
 
  1238 			if(AsciiToNum(trafficCap, digit)==KErrNone)
 
  1244 			if(AsciiToNum(trafficCap, digit)==KErrNone)
 
  1239 				iCapsR99.iTraffic = digit;
 
  1245 				iCapsR99.iTraffic = digit;
 
  1240 
  1246 
  1241 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,deliveryOrderReqCap);
 
  1247 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,deliveryOrderReqCap);
 
  1242 		if(ret!=KErrNone)
 
  1248 		if(ret!=KErrNone)
 
  1243 			{
 
  1249 			{
 
  1244 			LOGPARSERR("QosProfileCapsR99::deliveryOrderReqCap",ret,1,&KQosProfileCapsR99);
 
  1250 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99QOSPROFILECAPS_2, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSR99::DELIVERYORDERREQCAP returned %d (element no. %d) from tag %s.",ret,1,KQosProfileCapsR99);
 
  1245 			}
 
  1251 			}
 
  1246 		else
 
  1252 		else
 
  1247 			if(AsciiToNum(deliveryOrderReqCap, digit)==KErrNone)
 
  1253 			if(AsciiToNum(deliveryOrderReqCap, digit)==KErrNone)
 
  1248 				iCapsR99.iDeliveryOrderReq = digit;
 
  1254 				iCapsR99.iDeliveryOrderReq = digit;
 
  1249 
  1255 
  1250 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,deliverErroneousSDUCap);
 
  1256 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,deliverErroneousSDUCap);
 
  1251 		if(ret!=KErrNone)
 
  1257 		if(ret!=KErrNone)
 
  1252 			{
 
  1258 			{
 
  1253 			LOGPARSERR("QosProfileCapsR99::deliverErroneousSDUCap",ret,2,&KQosProfileCapsR99);
 
  1259 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99QOSPROFILECAPS_3, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSR99::DELIVERERRONEOUSSDUCAP returned %d (element no. %d) from tag %s.",ret,2,KQosProfileCapsR99);
 
  1254 			}
 
  1260 			}
 
  1255 		else
 
  1261 		else
 
  1256 			if(AsciiToNum(deliverErroneousSDUCap, digit)==KErrNone)
 
  1262 			if(AsciiToNum(deliverErroneousSDUCap, digit)==KErrNone)
 
  1257 				iCapsR99.iDeliverErroneousSDU = digit;
 
  1263 				iCapsR99.iDeliverErroneousSDU = digit;
 
  1258 
  1264 
  1259 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,BERCap);
 
  1265 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,BERCap);
 
  1260 		if(ret!=KErrNone)
 
  1266 		if(ret!=KErrNone)
 
  1261 			{
 
  1267 			{
 
  1262 			LOGPARSERR("QosProfileCapsR99::BERCap",ret,3,&KQosProfileCapsR99);
 
  1268 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99QOSPROFILECAPS_4, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSR99::BERCAP returned %d (element no. %d) from tag %s.",ret,3,KQosProfileCapsR99);
 
  1263 			}
 
  1269 			}
 
  1264 		else
 
  1270 		else
 
  1265 			if(AsciiToNum(BERCap, digit)==KErrNone)
 
  1271 			if(AsciiToNum(BERCap, digit)==KErrNone)
 
  1266 				iCapsR99.iBER = digit;
 
  1272 				iCapsR99.iBER = digit;
 
  1267 
  1273 
  1268 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,SDUErrorRatioCap);
 
  1274 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,SDUErrorRatioCap);
 
  1269 		if(ret!=KErrNone)
 
  1275 		if(ret!=KErrNone)
 
  1270 			{
 
  1276 			{
 
  1271 			LOGPARSERR("QosProfileCapsR99::SDUErrorRatioCap",ret,4,&KQosProfileCapsR99);
 
  1277 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99QOSPROFILECAPS_5, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSR99::SDUERRORRATIOCAP returned %d (element no. %d) from tag %s.",ret,4,KQosProfileCapsR99);
 
  1272 			}
 
  1278 			}
 
  1273 		else
 
  1279 		else
 
  1274 			if(AsciiToNum(SDUErrorRatioCap, digit)==KErrNone)
 
  1280 			if(AsciiToNum(SDUErrorRatioCap, digit)==KErrNone)
 
  1275 				iCapsR99.iSDUErrorRatio = digit;
 
  1281 				iCapsR99.iSDUErrorRatio = digit;
 
  1276 
  1282 
  1277 
  1283 
  1278 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,trafficHandlingPriorityCap);
 
  1284 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,trafficHandlingPriorityCap);
 
  1279 		if(ret!=KErrNone)
 
  1285 		if(ret!=KErrNone)
 
  1280 			{
 
  1286 			{
 
  1281 			LOGPARSERR("QosProfileCapsR99::trafficHandlingPriorityCap",ret,5,&KQosProfileCapsR99);
 
  1287 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR99QOSPROFILECAPS_6, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSR99::TRAFFICHANDLINGPRIORITYCAP returned %d (element no. %d) from tag %s.",ret,5,KQosProfileCapsR99);
 
  1282 			}
 
  1288 			}
 
  1283 		else
 
  1289 		else
 
  1284 			if(AsciiToNum(trafficHandlingPriorityCap, digit)==KErrNone)
 
  1290 			if(AsciiToNum(trafficHandlingPriorityCap, digit)==KErrNone)
 
  1285 				iCapsR99.iTrafficHandlingPriority = digit;
 
  1291 				iCapsR99.iTrafficHandlingPriority = digit;
 
  1286 		}
 
  1292 		}
 
  1300 		TPtrC8 signallingIndication, sourceStatisticsDescriptor;
 
  1306 		TPtrC8 signallingIndication, sourceStatisticsDescriptor;
 
  1301 
  1307 
  1302 		TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,trafficCap);
 
  1308 		TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,trafficCap);
 
  1303 		if(ret!=KErrNone)
 
  1309 		if(ret!=KErrNone)
 
  1304 			{
 
  1310 			{
 
  1305 			LOGPARSERR("QosProfileCapsR5::trafficCap",ret,0,&KQosProfileCapsR5);
 
  1311 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5QOSPROFILECAPS_1, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSR5::TRAFFICCAP returned %d (element no. %d) from tag %s.",ret,0,KQosProfileCapsR5);
 
  1306 			}
 
  1312 			}
 
  1307 		else
 
  1313 		else
 
  1308 			if(AsciiToNum(trafficCap, digit)==KErrNone)
 
  1314 			if(AsciiToNum(trafficCap, digit)==KErrNone)
 
  1309 				iCapsR5.iTraffic = digit;
 
  1315 				iCapsR5.iTraffic = digit;
 
  1310 
  1316 
  1311 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,deliveryOrderReqCap);
 
  1317 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,deliveryOrderReqCap);
 
  1312 		if(ret!=KErrNone)
 
  1318 		if(ret!=KErrNone)
 
  1313 			{
 
  1319 			{
 
  1314 			LOGPARSERR("QosProfileCapsR5::deliveryOrderReqCap",ret,1,&KQosProfileCapsR5);
 
  1320 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5QOSPROFILECAPS_2, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSR5::DELIVERYORDERREQCAP returned %d (element no. %d) from tag %s.",ret,1,KQosProfileCapsR5);
 
  1315 			}
 
  1321 			}
 
  1316 		else
 
  1322 		else
 
  1317 			if(AsciiToNum(deliveryOrderReqCap, digit)==KErrNone)
 
  1323 			if(AsciiToNum(deliveryOrderReqCap, digit)==KErrNone)
 
  1318 				iCapsR5.iDeliveryOrderReq = digit;
 
  1324 				iCapsR5.iDeliveryOrderReq = digit;
 
  1319 
  1325 
  1320 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,deliverErroneousSDUCap);
 
  1326 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,deliverErroneousSDUCap);
 
  1321 		if(ret!=KErrNone)
 
  1327 		if(ret!=KErrNone)
 
  1322 			{
 
  1328 			{
 
  1323 			LOGPARSERR("QosProfileCapsR5::deliverErroneousSDUCap",ret,2,&KQosProfileCapsR5);
 
  1329 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5QOSPROFILECAPS_3, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSR5::DELIVERERRONEOUSSDUCAP returned %d (element no. %d) from tag %s.",ret,2,KQosProfileCapsR5);
 
  1324 			}
 
  1330 			}
 
  1325 		else
 
  1331 		else
 
  1326 			if(AsciiToNum(deliverErroneousSDUCap, digit)==KErrNone)
 
  1332 			if(AsciiToNum(deliverErroneousSDUCap, digit)==KErrNone)
 
  1327 				iCapsR5.iDeliverErroneousSDU = digit;
 
  1333 				iCapsR5.iDeliverErroneousSDU = digit;
 
  1328 
  1334 
  1329 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,BERCap);
 
  1335 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,BERCap);
 
  1330 		if(ret!=KErrNone)
 
  1336 		if(ret!=KErrNone)
 
  1331 			{
 
  1337 			{
 
  1332 			LOGPARSERR("QosProfileCapsR5::BERCap",ret,3,&KQosProfileCapsR5);
 
  1338 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5QOSPROFILECAPS_4, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSR5::BERCAP returned %d (element no. %d) from tag %s.",ret,3,KQosProfileCapsR5);
 
  1333 			}
 
  1339 			}
 
  1334 		else
 
  1340 		else
 
  1335 			if(AsciiToNum(BERCap, digit)==KErrNone)
 
  1341 			if(AsciiToNum(BERCap, digit)==KErrNone)
 
  1336 				iCapsR5.iBER = digit;
 
  1342 				iCapsR5.iBER = digit;
 
  1337 
  1343 
  1338 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,SDUErrorRatioCap);
 
  1344 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,SDUErrorRatioCap);
 
  1339 		if(ret!=KErrNone)
 
  1345 		if(ret!=KErrNone)
 
  1340 			{
 
  1346 			{
 
  1341 			LOGPARSERR("QosProfileCapsR5::SDUErrorRatioCap",ret,4,&KQosProfileCapsR5);
 
  1347 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5QOSPROFILECAPS_5, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSR5::SDUERRORRATIOCAP returned %d (element no. %d) from tag %s.",ret,4,KQosProfileCapsR5);
 
  1342 			}
 
  1348 			}
 
  1343 		else
 
  1349 		else
 
  1344 			if(AsciiToNum(SDUErrorRatioCap, digit)==KErrNone)
 
  1350 			if(AsciiToNum(SDUErrorRatioCap, digit)==KErrNone)
 
  1345 				iCapsR5.iSDUErrorRatio = digit;
 
  1351 				iCapsR5.iSDUErrorRatio = digit;
 
  1346 
  1352 
  1347 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,trafficHandlingPriorityCap);
 
  1353 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,trafficHandlingPriorityCap);
 
  1348 		if(ret!=KErrNone)
 
  1354 		if(ret!=KErrNone)
 
  1349 			{
 
  1355 			{
 
  1350 			LOGPARSERR("QosProfileCapsR5::trafficHandlingPriorityCap",ret,5,&KQosProfileCapsR5);
 
  1356 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5QOSPROFILECAPS_6, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSR5::TRAFFICHANDLINGPRIORITYCAP returned %d (element no. %d) from tag %s.",ret,5,KQosProfileCapsR5);
 
  1351 			}
 
  1357 			}
 
  1352 		else
 
  1358 		else
 
  1353 			if(AsciiToNum(trafficHandlingPriorityCap, digit)==KErrNone)
 
  1359 			if(AsciiToNum(trafficHandlingPriorityCap, digit)==KErrNone)
 
  1354 				iCapsR5.iTrafficHandlingPriority = digit;
 
  1360 				iCapsR5.iTrafficHandlingPriority = digit;
 
  1355 		
  1361 		
  1356 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,signallingIndication);
 
  1362 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,signallingIndication);
 
  1357 		if(ret!=KErrNone)
 
  1363 		if(ret!=KErrNone)
 
  1358 			{
 
  1364 			{
 
  1359 			LOGPARSERR("QosProfileCapsR5::signallingIndication",ret,6,&KQosProfileCapsR5);
 
  1365 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5QOSPROFILECAPS_7, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSR5::SIGNALLINGINDICATION returned %d (element no. %d) from tag %s.",ret,6,KQosProfileCapsR5);
 
  1360 			}
 
  1366 			}
 
  1361 		else
 
  1367 		else
 
  1362 			if(AsciiToNum(signallingIndication, digit)==KErrNone)
 
  1368 			if(AsciiToNum(signallingIndication, digit)==KErrNone)
 
  1363 				iCapsR5.iSignallingIndication = digit;
 
  1369 				iCapsR5.iSignallingIndication = digit;
 
  1364 			
  1370 			
  1365 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,sourceStatisticsDescriptor);
 
  1371 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,sourceStatisticsDescriptor);
 
  1366 		if(ret!=KErrNone)
 
  1372 		if(ret!=KErrNone)
 
  1367 			{
 
  1373 			{
 
  1368 			LOGPARSERR("QosProfileCapsR5::sourceStatisticsDescriptor",ret,7,&KQosProfileCapsR5);
 
  1374 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5QOSPROFILECAPS_8, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSR5::SOURCESTATISTICSDESCRIPTOR returned %d (element no. %d) from tag %s.",ret,7,KQosProfileCapsR5);
 
  1369 			}
 
  1375 			}
 
  1370 		else
 
  1376 		else
 
  1371 			if(AsciiToNum(sourceStatisticsDescriptor, digit)==KErrNone)
 
  1377 			if(AsciiToNum(sourceStatisticsDescriptor, digit)==KErrNone)
 
  1372 				iCapsR5.iNegTSourceStatisticsDescriptor = digit;
 
  1378 				iCapsR5.iNegTSourceStatisticsDescriptor = digit;
 
  1373 		}
 
  1379 		}
 
  1387 		if (iPacketContext->ContextName().Compare(tempContextName)==0)
 
  1393 		if (iPacketContext->ContextName().Compare(tempContextName)==0)
 
  1388 			{
 
  1394 			{
 
  1389 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,numberOfTimes);
 
  1395 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,numberOfTimes);
 
  1390 			if(ret!=KErrNone)
 
  1396 			if(ret!=KErrNone)
 
  1391 				{
 
  1397 				{
 
  1392 				LOGPARSERR("SetProfileFail::numberOfTimes",ret,1,&KSetProfileFail);
 
  1398 				OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETPROFILEFAILSETTINGS_1, "WARNING - CONFIGURATION FILE PARSING - Reading element SETPROFILEFAIL::NUMBEROFTIMES returned %d (element no. %d) from tag %s.",ret,1,KSetProfileFail);
 
  1393 				}
 
  1399 				}
 
  1394 			else
 
  1400 			else
 
  1395 				{
 
  1401 				{
 
  1396 				if(AsciiToNum(numberOfTimes, setProfileDigit)==KErrNone)
 
  1402 				if(AsciiToNum(numberOfTimes, setProfileDigit)==KErrNone)
 
  1397 					iSetProfileFail.iNumberOfTimes = setProfileDigit;
 
  1403 					iSetProfileFail.iNumberOfTimes = setProfileDigit;
 
  1398 				}
 
  1404 				}
 
  1399 		
  1405 		
  1400 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,errorCode);
 
  1406 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,errorCode);
 
  1401 			if(ret!=KErrNone)
 
  1407 			if(ret!=KErrNone)
 
  1402 				{
 
  1408 				{
 
  1403 				LOGPARSERR("SetProfileFail::errorCode",ret,2,&KSetProfileFail);
 
  1409 				OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETPROFILEFAILSETTINGS_2, "WARNING - CONFIGURATION FILE PARSING - Reading element SETPROFILEFAIL::ERRORCODE returned %d (element no. %d) from tag %s.",ret,2,KSetProfileFail);
 
  1404 				}
 
  1410 				}
 
  1405 			else
 
  1411 			else
 
  1406 				{
 
  1412 				{
 
  1407 				if(AsciiToNum(errorCode, setProfileDigit)==KErrNone)
 
  1413 				if(AsciiToNum(errorCode, setProfileDigit)==KErrNone)
 
  1408 					iSetProfileFail.iFailErrorCode = setProfileDigit;
 
  1414 					iSetProfileFail.iFailErrorCode = setProfileDigit;
 
  1426 		TPtrC8 negPrecedenceCap, negDelayCap, negPeekCap, negReliabilityCap, negMeanCap;
 
  1432 		TPtrC8 negPrecedenceCap, negDelayCap, negPeekCap, negReliabilityCap, negMeanCap;
 
  1427 
  1433 
  1428 		TInt ret = CTestConfig::GetElement(item->Value(),KStdDelimiter,0,negPrecedenceCap);
 
  1434 		TInt ret = CTestConfig::GetElement(item->Value(),KStdDelimiter,0,negPrecedenceCap);
 
  1429 		if(ret!=KErrNone)
 
  1435 		if(ret!=KErrNone)
 
  1430 			{
 
  1436 			{
 
  1431 			LOGPARSERR("QosProfileCapsGPRS::negPrecedenceCap",ret,0,&KQosProfileCapsGPRS);
 
  1437 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSQOSPROFILECAPS_1, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSGPRS::NEGPRECEDENCECAP returned %d (element no. %d) from tag %s.",ret,0,KQosProfileCapsGPRS);
 
  1432 			}
 
  1438 			}
 
  1433 		else
 
  1439 		else
 
  1434 			if(AsciiToNum(negPrecedenceCap, digit)==KErrNone)
 
  1440 			if(AsciiToNum(negPrecedenceCap, digit)==KErrNone)
 
  1435 				iCapsGPRS.iPrecedence = digit;
 
  1441 				iCapsGPRS.iPrecedence = digit;
 
  1436 
  1442 
  1437 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,negDelayCap);
 
  1443 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,negDelayCap);
 
  1438 		if(ret!=KErrNone)
 
  1444 		if(ret!=KErrNone)
 
  1439 			{
 
  1445 			{
 
  1440 			LOGPARSERR("QosProfileCapsGPRS::negDelayCap",ret,1,&KQosProfileCapsGPRS);
 
  1446 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSQOSPROFILECAPS_2, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSGPRS::NEGDELAYCAP returned %d (element no. %d) from tag %s.",ret,1,KQosProfileCapsGPRS);
 
  1441 			}
 
  1447 			}
 
  1442 		else
 
  1448 		else
 
  1443 			if(AsciiToNum(negDelayCap, digit)==KErrNone)
 
  1449 			if(AsciiToNum(negDelayCap, digit)==KErrNone)
 
  1444 				iCapsGPRS.iDelay = digit;
 
  1450 				iCapsGPRS.iDelay = digit;
 
  1445 
  1451 
  1446 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,negReliabilityCap);
 
  1452 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,negReliabilityCap);
 
  1447 		if(ret!=KErrNone)
 
  1453 		if(ret!=KErrNone)
 
  1448 			{
 
  1454 			{
 
  1449 			LOGPARSERR("QosProfileCapsGPRS::negReliabilityCap",ret,2,&KQosProfileCapsGPRS);
 
  1455 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSQOSPROFILECAPS_3, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSGPRS::NEGRELIABILITYCAP returned %d (element no. %d) from tag %s.",ret,2,KQosProfileCapsGPRS);
 
  1450 			}
 
  1456 			}
 
  1451 		else
 
  1457 		else
 
  1452 			if(AsciiToNum(negReliabilityCap, digit)==KErrNone)
 
  1458 			if(AsciiToNum(negReliabilityCap, digit)==KErrNone)
 
  1453 				iCapsGPRS.iReliability = digit;
 
  1459 				iCapsGPRS.iReliability = digit;
 
  1454 
  1460 
  1455 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,negPeekCap);
 
  1461 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,negPeekCap);
 
  1456 		if(ret!=KErrNone)
 
  1462 		if(ret!=KErrNone)
 
  1457 			{
 
  1463 			{
 
  1458 			LOGPARSERR("QosProfileCapsGPRS::negPeekCap",ret,3,&KQosProfileCapsGPRS);
 
  1464 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSQOSPROFILECAPS_4, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSGPRS::NEGPEEKCAP returned %d (element no. %d) from tag %s.",ret,3,KQosProfileCapsGPRS);
 
  1459 			}
 
  1465 			}
 
  1460 		else
 
  1466 		else
 
  1461 			if(AsciiToNum(negPeekCap, digit)==KErrNone)
 
  1467 			if(AsciiToNum(negPeekCap, digit)==KErrNone)
 
  1462 				iCapsGPRS.iPeak = digit;
 
  1468 				iCapsGPRS.iPeak = digit;
 
  1463 
  1469 
  1464 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,negMeanCap);
 
  1470 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,negMeanCap);
 
  1465 		if(ret!=KErrNone)
 
  1471 		if(ret!=KErrNone)
 
  1466 			{
 
  1472 			{
 
  1467 			LOGPARSERR("QosProfileCapsGPRS::negMeanCap",ret,4,&KQosProfileCapsGPRS);
 
  1473 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETGPRSQOSPROFILECAPS_5, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILECAPSGPRS::NEGMEANCAP returned %d (element no. %d) from tag %s.",ret,4,KQosProfileCapsGPRS);
 
  1468 			}
 
  1474 			}
 
  1469 		else
 
  1475 		else
 
  1470 			if(AsciiToNum(negMeanCap, digit)==KErrNone)
 
  1476 			if(AsciiToNum(negMeanCap, digit)==KErrNone)
 
  1471 				iCapsGPRS.iMean = digit;
 
  1477 				iCapsGPRS.iMean = digit;
 
  1472 
  1478 
  1503 		TPtrC8 reqTSourceStatisticsDescriptor;
 
  1509 		TPtrC8 reqTSourceStatisticsDescriptor;
 
  1504 
  1510 
  1505 		TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextName);
 
  1511 		TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextName);
 
  1506 		if(ret!=KErrNone)
 
  1512 		if(ret!=KErrNone)
 
  1507 			{
 
  1513 			{
 
  1508 			LOGPARSERR("QosProfileReqR5::contextName",ret,0,&KQosProfileReqR5);
 
  1514 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_1, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::CONTEXTNAME returned %d (element no. %d) from tag %s.",ret,0,KQosProfileReqR5);
 
  1509 			continue;
 
  1515 			continue;
 
  1510 			}
 
  1516 			}
 
  1511 		else 
  1517 		else 
  1512 			{
 
  1518 			{
 
  1513 			profileReq5.iContextName.Copy(contextName);
 
  1519 			profileReq5.iContextName.Copy(contextName);
 
  1514 			if (profileReq5.iContextName.Match(iPacketContext->ContextName())==KErrNotFound)
 
  1520 			if (profileReq5.iContextName.Match(iPacketContext->ContextName())==KErrNotFound)
 
  1515 				{
 
  1521 				{
 
  1516 				LOGPARSERR("QosProfileReqR5::contextName",KErrArgument,0,&KQosProfileReqR5);
 
  1522 				OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_2, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::CONTEXTNAME returned %d (element no. %d) from tag %s.",KErrArgument,0,KQosProfileReqR5);
 
  1517 				continue;
 
  1523 				continue;
 
  1518 				}
 
  1524 				}
 
  1519 			}
 
  1525 			}
 
  1520 
  1526 
  1521 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,reqTraffic);
 
  1527 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,reqTraffic);
 
  1522 		if(ret!=KErrNone)
 
  1528 		if(ret!=KErrNone)
 
  1523 			{
 
  1529 			{
 
  1524 			LOGPARSERR("QosProfileReqR5::reqTraffic",ret,1,&KQosProfileReqR5);
 
  1530 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_3, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::REQTRAFFIC returned %d (element no. %d) from tag %s.",ret,1,KQosProfileReqR5);
 
  1525 			continue;
 
  1531 			continue;
 
  1526 			}
 
  1532 			}
 
  1527 		else 
  1533 		else 
  1528 			{
 
  1534 			{
 
  1529 			if(AsciiToNum(reqTraffic, digit)==KErrNone)
 
  1535 			if(AsciiToNum(reqTraffic, digit)==KErrNone)
 
  1533 			}
 
  1539 			}
 
  1534 
  1540 
  1535 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,minTraffic);
 
  1541 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,minTraffic);
 
  1536 		if(ret!=KErrNone)
 
  1542 		if(ret!=KErrNone)
 
  1537 			{
 
  1543 			{
 
  1538 			LOGPARSERR("QosProfileReqR5::minTraffic",ret,2,&KQosProfileReqR5);
 
  1544 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_4, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::MINTRAFFIC returned %d (element no. %d) from tag %s.",ret,2,KQosProfileReqR5);
 
  1539 			continue;
 
  1545 			continue;
 
  1540 			}
 
  1546 			}
 
  1541 		else 
  1547 		else 
  1542 			{
 
  1548 			{
 
  1543 			if(AsciiToNum(minTraffic, digit)==KErrNone)
 
  1549 			if(AsciiToNum(minTraffic, digit)==KErrNone)
 
  1547 			}
 
  1553 			}
 
  1548 
  1554 
  1549 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,reqDeliveryOrder);
 
  1555 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,reqDeliveryOrder);
 
  1550 		if(ret!=KErrNone)
 
  1556 		if(ret!=KErrNone)
 
  1551 			{
 
  1557 			{
 
  1552 			LOGPARSERR("QosProfileReqR5::reqDeliveryOrder",ret,3,&KQosProfileReqR5);
 
  1558 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_5, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::REQDELIVERYORDER returned %d (element no. %d) from tag %s.",ret,3,KQosProfileReqR5);
 
  1553 			continue;
 
  1559 			continue;
 
  1554 			}
 
  1560 			}
 
  1555 		else 
  1561 		else 
  1556 			{
 
  1562 			{
 
  1557 			if(AsciiToNum(reqDeliveryOrder, digit)==KErrNone)
 
  1563 			if(AsciiToNum(reqDeliveryOrder, digit)==KErrNone)
 
  1561 			}
 
  1567 			}
 
  1562 
  1568 
  1563 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,minDeliveryOrder);
 
  1569 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,minDeliveryOrder);
 
  1564 		if(ret!=KErrNone)
 
  1570 		if(ret!=KErrNone)
 
  1565 			{
 
  1571 			{
 
  1566 			LOGPARSERR("QosProfileReqR5::minDeliveryOrder",ret,4,&KQosProfileReqR5);
 
  1572 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_6, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::MINDELIVERYORDER returned %d (element no. %d) from tag %s.",ret,4,KQosProfileReqR5);
 
  1567 			continue;
 
  1573 			continue;
 
  1568 			}
 
  1574 			}
 
  1569 		else 
  1575 		else 
  1570 			{
 
  1576 			{
 
  1571 			if(AsciiToNum(minDeliveryOrder, digit)==KErrNone)
 
  1577 			if(AsciiToNum(minDeliveryOrder, digit)==KErrNone)
 
  1575 			}
 
  1581 			}
 
  1576 
  1582 
  1577 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,reqErroneousSDU);
 
  1583 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,reqErroneousSDU);
 
  1578 		if(ret!=KErrNone)
 
  1584 		if(ret!=KErrNone)
 
  1579 			{
 
  1585 			{
 
  1580 			LOGPARSERR("QosProfileReqR5::reqErroneousSDU",ret,5,&KQosProfileReqR5);
 
  1586 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_7, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::REQERRONEOUSSDU returned %d (element no. %d) from tag %s.",ret,5,KQosProfileReqR5);
 
  1581 			continue;
 
  1587 			continue;
 
  1582 			}
 
  1588 			}
 
  1583 		else 
  1589 		else 
  1584 			{
 
  1590 			{
 
  1585 			if(AsciiToNum(reqErroneousSDU, digit)==KErrNone)
 
  1591 			if(AsciiToNum(reqErroneousSDU, digit)==KErrNone)
 
  1589 			}
 
  1595 			}
 
  1590 
  1596 
  1591 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,minErroneousSDU);
 
  1597 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,minErroneousSDU);
 
  1592 		if(ret!=KErrNone)
 
  1598 		if(ret!=KErrNone)
 
  1593 			{
 
  1599 			{
 
  1594 			LOGPARSERR("QosProfileReqR5::minErroneousSDU",ret,6,&KQosProfileReqR5);
 
  1600 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_8, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::MINERRONEOUSSDU returned %d (element no. %d) from tag %s.",ret,6,KQosProfileReqR5);
 
  1595 			continue;
 
  1601 			continue;
 
  1596 			}
 
  1602 			}
 
  1597 		else 
  1603 		else 
  1598 			{
 
  1604 			{
 
  1599 			if(AsciiToNum(minErroneousSDU, digit)==KErrNone)
 
  1605 			if(AsciiToNum(minErroneousSDU, digit)==KErrNone)
 
  1603 			}
 
  1609 			}
 
  1604 
  1610 
  1605 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,maxSDUSize);
 
  1611 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,maxSDUSize);
 
  1606 		if(ret!=KErrNone)
 
  1612 		if(ret!=KErrNone)
 
  1607 			{
 
  1613 			{
 
  1608 			LOGPARSERR("QosProfileReqR5::maxSDUSize",ret,7,&KQosProfileReqR5);
 
  1614 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_9, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::MAXSDUSIZE returned %d (element no. %d) from tag %s.",ret,7,KQosProfileReqR5);
 
  1609 			continue;
 
  1615 			continue;
 
  1610 			}
 
  1616 			}
 
  1611 		else 
  1617 		else 
  1612 			{
 
  1618 			{
 
  1613 			profileReq5.iMaxSDUSize=maxSDUSize;
 
  1619 			profileReq5.iMaxSDUSize=maxSDUSize;
 
  1614 			}
 
  1620 			}
 
  1615 
  1621 
  1616 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,minSDUSize);
 
  1622 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,minSDUSize);
 
  1617 		if(ret!=KErrNone)
 
  1623 		if(ret!=KErrNone)
 
  1618 			{
 
  1624 			{
 
  1619 			LOGPARSERR("QosProfileReqR5::minSDUSize",ret,8,&KQosProfileReqR5);
 
  1625 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_10, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::MINSDUSIZE returned %d (element no. %d) from tag %s.",ret,8,KQosProfileReqR5);
 
  1620 			continue;
 
  1626 			continue;
 
  1621 			}
 
  1627 			}
 
  1622 		else 
  1628 		else 
  1623 			{
 
  1629 			{
 
  1624 			profileReq5.iMinSDUSize=minSDUSize;
 
  1630 			profileReq5.iMinSDUSize=minSDUSize;
 
  1625 			}
 
  1631 			}
 
  1626 
  1632 
  1627 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,reqUpLinkBitRate);
 
  1633 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,reqUpLinkBitRate);
 
  1628 		if(ret!=KErrNone)
 
  1634 		if(ret!=KErrNone)
 
  1629 			{
 
  1635 			{
 
  1630 			LOGPARSERR("QosProfileReqR5::reqUpLinkBitRate",ret,9,&KQosProfileReqR5);
 
  1636 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_11, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::REQUPLINKBITRATE returned %d (element no. %d) from tag %s.",ret,9,KQosProfileReqR5);
 
  1631 			continue;
 
  1637 			continue;
 
  1632 			}
 
  1638 			}
 
  1633 		else 
  1639 		else 
  1634 			{
 
  1640 			{
 
  1635 			profileReq5.iReqUpLinkTBitRate=reqUpLinkBitRate;
 
  1641 			profileReq5.iReqUpLinkTBitRate=reqUpLinkBitRate;
 
  1636 			}
 
  1642 			}
 
  1637 
  1643 
  1638 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,reqDownLinkBitRate);
 
  1644 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,reqDownLinkBitRate);
 
  1639 		if(ret!=KErrNone)
 
  1645 		if(ret!=KErrNone)
 
  1640 			{
 
  1646 			{
 
  1641 			LOGPARSERR("QosProfileReqR5::reqDownLinkBitRate",ret,10,&KQosProfileReqR5);
 
  1647 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_12, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::REQDOWNLINKBITRATE returned %d (element no. %d) from tag %s.",ret,10,KQosProfileReqR5);
 
  1642 			continue;
 
  1648 			continue;
 
  1643 			}
 
  1649 			}
 
  1644 		else 
  1650 		else 
  1645 			{
 
  1651 			{
 
  1646 			profileReq5.iReqDownLinkTBitRate= reqDownLinkBitRate;
 
  1652 			profileReq5.iReqDownLinkTBitRate= reqDownLinkBitRate;
 
  1647 			}
 
  1653 			}
 
  1648 
  1654 
  1649 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,minUpLinkBitRate);
 
  1655 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,minUpLinkBitRate);
 
  1650 		if(ret!=KErrNone)
 
  1656 		if(ret!=KErrNone)
 
  1651 			{
 
  1657 			{
 
  1652 			LOGPARSERR("QosProfileReqR5::minUpLinkBitRate",ret,11,&KQosProfileReqR5);
 
  1658 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_13, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::MINUPLINKBITRATE returned %d (element no. %d) from tag %s.",ret,11,KQosProfileReqR5);
 
  1653 			continue;
 
  1659 			continue;
 
  1654 			}
 
  1660 			}
 
  1655 		else 
  1661 		else 
  1656 			{
 
  1662 			{
 
  1657 			profileReq5.iMinUpLinkTBitRate= minUpLinkBitRate;
 
  1663 			profileReq5.iMinUpLinkTBitRate= minUpLinkBitRate;
 
  1668 			}
 
  1674 			}
 
  1669 
  1675 
  1670 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,13,reqBitErrorRatio);
 
  1676 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,13,reqBitErrorRatio);
 
  1671 		if(ret!=KErrNone)
 
  1677 		if(ret!=KErrNone)
 
  1672 			{
 
  1678 			{
 
  1673 			LOGPARSERR("QosProfileReqR5::reqBitErrorRatio",ret,13,&KQosProfileReqR5);
 
  1679 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_14, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::REQBITERRORRATIO returned %d (element no. %d) from tag %s.",ret,13,KQosProfileReqR5);
 
  1674 			continue;
 
  1680 			continue;
 
  1675 			}
 
  1681 			}
 
  1676 		else 
  1682 		else 
  1677 			{
 
  1683 			{
 
  1678 			if(AsciiToNum(reqBitErrorRatio, digit)==KErrNone)
 
  1684 			if(AsciiToNum(reqBitErrorRatio, digit)==KErrNone)
 
  1682 			}
 
  1688 			}
 
  1683 
  1689 
  1684 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,14,minBitErrorRatio);
 
  1690 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,14,minBitErrorRatio);
 
  1685 		if(ret!=KErrNone)
 
  1691 		if(ret!=KErrNone)
 
  1686 			{
 
  1692 			{
 
  1687 			LOGPARSERR("QosProfileReqR5::minBitErrorRatio",ret,14,&KQosProfileReqR5);
 
  1693 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_15, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::MINBITERRORRATIO returned %d (element no. %d) from tag %s.",ret,14,KQosProfileReqR5);
 
  1688 			continue;
 
  1694 			continue;
 
  1689 			}
 
  1695 			}
 
  1690 		else 
  1696 		else 
  1691 			{
 
  1697 			{
 
  1692 			if(AsciiToNum(minBitErrorRatio, digit)==KErrNone)
 
  1698 			if(AsciiToNum(minBitErrorRatio, digit)==KErrNone)
 
  1696 			}
 
  1702 			}
 
  1697 
  1703 
  1698 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,15,reqSDUErrorRatio);
 
  1704 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,15,reqSDUErrorRatio);
 
  1699 		if(ret!=KErrNone)
 
  1705 		if(ret!=KErrNone)
 
  1700 			{
 
  1706 			{
 
  1701 			LOGPARSERR("- QosProfileReqR5::reqSDUErrorRatio",ret,15,&KQosProfileReqR5);
 
  1707 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_16, "WARNING - CONFIGURATION FILE PARSING - Reading element - QOSPROFILEREQR5::REQSDUERRORRATIO returned %d (element no. %d) from tag %s.",ret,15,KQosProfileReqR5);
 
  1702 			continue;
 
  1708 			continue;
 
  1703 			}
 
  1709 			}
 
  1704 		else 
  1710 		else 
  1705 			{
 
  1711 			{
 
  1706 			if(AsciiToNum(reqSDUErrorRatio, digit)==KErrNone)
 
  1712 			if(AsciiToNum(reqSDUErrorRatio, digit)==KErrNone)
 
  1710 			}
 
  1716 			}
 
  1711 
  1717 
  1712 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,16,minSDUErrorRatio);
 
  1718 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,16,minSDUErrorRatio);
 
  1713 		if(ret!=KErrNone)
 
  1719 		if(ret!=KErrNone)
 
  1714 			{
 
  1720 			{
 
  1715 			LOGPARSERR("- QosProfileReqR5::minSDUErrorRatio",ret,16,&KQosProfileReqR5);
 
  1721 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_17, "WARNING - CONFIGURATION FILE PARSING - Reading element - QOSPROFILEREQR5::MINSDUERRORRATIO returned %d (element no. %d) from tag %s.",ret,16,KQosProfileReqR5);
 
  1716 			continue;
 
  1722 			continue;
 
  1717 			}
 
  1723 			}
 
  1718 		else 
  1724 		else 
  1719 			{
 
  1725 			{
 
  1720 			if(AsciiToNum(minSDUErrorRatio, digit)==KErrNone)
 
  1726 			if(AsciiToNum(minSDUErrorRatio, digit)==KErrNone)
 
  1724 			}
 
  1730 			}
 
  1725 
  1731 
  1726 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,17,reqTrafficHandlingPriority);
 
  1732 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,17,reqTrafficHandlingPriority);
 
  1727 		if(ret!=KErrNone)
 
  1733 		if(ret!=KErrNone)
 
  1728 			{
 
  1734 			{
 
  1729 			LOGPARSERR("QosProfileReqR5::reqTrafficHandlingPriority",ret,17,&KQosProfileReqR5);
 
  1735 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_18, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::REQTRAFFICHANDLINGPRIORITY returned %d (element no. %d) from tag %s.",ret,17,KQosProfileReqR5);
 
  1730 			continue;
 
  1736 			continue;
 
  1731 			}
 
  1737 			}
 
  1732 		else 
  1738 		else 
  1733 			{
 
  1739 			{
 
  1734 			if(AsciiToNum(reqTrafficHandlingPriority, digit)==KErrNone)
 
  1740 			if(AsciiToNum(reqTrafficHandlingPriority, digit)==KErrNone)
 
  1738 			}
 
  1744 			}
 
  1739 
  1745 
  1740 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,18,minTrafficHandlingPriority);
 
  1746 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,18,minTrafficHandlingPriority);
 
  1741 		if(ret!=KErrNone)
 
  1747 		if(ret!=KErrNone)
 
  1742 			{
 
  1748 			{
 
  1743 			LOGPARSERR("QosProfileReqR5::minTrafficHandlingPriority",ret,18,&KQosProfileReqR5);
 
  1749 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_19, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::MINTRAFFICHANDLINGPRIORITY returned %d (element no. %d) from tag %s.",ret,18,KQosProfileReqR5);
 
  1744 			continue;
 
  1750 			continue;
 
  1745 			}
 
  1751 			}
 
  1746 		else 
  1752 		else 
  1747 			{
 
  1753 			{
 
  1748 			if(AsciiToNum(minTrafficHandlingPriority, digit)==KErrNone)
 
  1754 			if(AsciiToNum(minTrafficHandlingPriority, digit)==KErrNone)
 
  1752 			}
 
  1758 			}
 
  1753 
  1759 
  1754 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,19,reqTransferDelay);
 
  1760 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,19,reqTransferDelay);
 
  1755 		if(ret!=KErrNone)
 
  1761 		if(ret!=KErrNone)
 
  1756 			{
 
  1762 			{
 
  1757 			LOGPARSERR("QosProfileReqR5::reqTransferDelay",ret,19,&KQosProfileReqR5);
 
  1763 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_20, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::REQTRANSFERDELAY returned %d (element no. %d) from tag %s.",ret,19,KQosProfileReqR5);
 
  1758 			continue;
 
  1764 			continue;
 
  1759 			}
 
  1765 			}
 
  1760 		else 
  1766 		else 
  1761 			{
 
  1767 			{
 
  1762 			profileReq5.iReqTransferDelay= reqTransferDelay;
 
  1768 			profileReq5.iReqTransferDelay= reqTransferDelay;
 
  1763 			}
 
  1769 			}
 
  1764 
  1770 
  1765 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,20,minTransferDelay);
 
  1771 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,20,minTransferDelay);
 
  1766 		if(ret!=KErrNone)
 
  1772 		if(ret!=KErrNone)
 
  1767 			{
 
  1773 			{
 
  1768 			LOGPARSERR("QosProfileReqR5::minTransferDelay",ret,20,&KQosProfileReqR5);
 
  1774 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_21, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::MINTRANSFERDELAY returned %d (element no. %d) from tag %s.",ret,20,KQosProfileReqR5);
 
  1769 			continue;
 
  1775 			continue;
 
  1770 			}
 
  1776 			}
 
  1771 		else 
  1777 		else 
  1772 			{
 
  1778 			{
 
  1773 			profileReq5.iMinTransferDelay= minTransferDelay;
 
  1779 			profileReq5.iMinTransferDelay= minTransferDelay;
 
  1774 			}
 
  1780 			}
 
  1775 
  1781 
  1776 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,21,reqGuaranteedUpLinkBitRate);
 
  1782 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,21,reqGuaranteedUpLinkBitRate);
 
  1777 		if(ret!=KErrNone)
 
  1783 		if(ret!=KErrNone)
 
  1778 			{
 
  1784 			{
 
  1779 			LOGPARSERR("QosProfileReqR5::reqGuaranteedUpLinkBitRate",ret,21,&KQosProfileReqR5);
 
  1785 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_22, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::REQGUARANTEEDUPLINKBITRATE returned %d (element no. %d) from tag %s.",ret,21,KQosProfileReqR5);
 
  1780 			continue;
 
  1786 			continue;
 
  1781 			}
 
  1787 			}
 
  1782 		else 
  1788 		else 
  1783 			{
 
  1789 			{
 
  1784 			profileReq5.iReqGuaranteedUpLinkTBitRate= reqGuaranteedUpLinkBitRate;
 
  1790 			profileReq5.iReqGuaranteedUpLinkTBitRate= reqGuaranteedUpLinkBitRate;
 
  1785 			}
 
  1791 			}
 
  1786 
  1792 
  1787 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,22,reqGuaranteedDownLinkBitRate);
 
  1793 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,22,reqGuaranteedDownLinkBitRate);
 
  1788 		if(ret!=KErrNone)
 
  1794 		if(ret!=KErrNone)
 
  1789 			{
 
  1795 			{
 
  1790 			LOGPARSERR("QosProfileReqR5::reqGuaranteedDownLinkBitRate",ret,22,&KQosProfileReqR5);
 
  1796 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_23, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::REQGUARANTEEDDOWNLINKBITRATE returned %d (element no. %d) from tag %s.",ret,22,KQosProfileReqR5);
 
  1791 			continue;
 
  1797 			continue;
 
  1792 			}
 
  1798 			}
 
  1793 		else 
  1799 		else 
  1794 			{
 
  1800 			{
 
  1795 			profileReq5.iReqGuaranteedDownLinkTBitRate= reqGuaranteedDownLinkBitRate;
 
  1801 			profileReq5.iReqGuaranteedDownLinkTBitRate= reqGuaranteedDownLinkBitRate;
 
  1796 			}
 
  1802 			}
 
  1797 
  1803 
  1798 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,23,minGuaranteedUpLinkBitRate);
 
  1804 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,23,minGuaranteedUpLinkBitRate);
 
  1799 		if(ret!=KErrNone)
 
  1805 		if(ret!=KErrNone)
 
  1800 			{
 
  1806 			{
 
  1801 			LOGPARSERR("QosProfileReqR5::minGuaranteedUpLinkBitRate",ret,23,&KQosProfileReqR5);
 
  1807 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_24, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::MINGUARANTEEDUPLINKBITRATE returned %d (element no. %d) from tag %s.",ret,23,KQosProfileReqR5);
 
  1802 			continue;
 
  1808 			continue;
 
  1803 			}
 
  1809 			}
 
  1804 		else 
  1810 		else 
  1805 			{
 
  1811 			{
 
  1806 			profileReq5.iMinGuaranteedUpLinkTBitRate= minGuaranteedUpLinkBitRate;
 
  1812 			profileReq5.iMinGuaranteedUpLinkTBitRate= minGuaranteedUpLinkBitRate;
 
  1807 			}
 
  1813 			}
 
  1808 
  1814 
  1809 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,24,minGuaranteedDownLinkBitRate);
 
  1815 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,24,minGuaranteedDownLinkBitRate);
 
  1810 		if(ret!=KErrNone)
 
  1816 		if(ret!=KErrNone)
 
  1811 			{
 
  1817 			{
 
  1812 			LOGPARSERR("QosProfileReqR5::minGuaranteedDownLinkBitRate",ret,24,&KQosProfileReqR5);
 
  1818 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_25, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::MINGUARANTEEDDOWNLINKBITRATE returned %d (element no. %d) from tag %s.",ret,24,KQosProfileReqR5);
 
  1813 			continue;
 
  1819 			continue;
 
  1814 			}
 
  1820 			}
 
  1815 		else 
  1821 		else 
  1816 			{
 
  1822 			{
 
  1817 			profileReq5.iMinGuaranteedDownLinkTBitRate= minGuaranteedDownLinkBitRate;
 
  1823 			profileReq5.iMinGuaranteedDownLinkTBitRate= minGuaranteedDownLinkBitRate;
 
  1818 			}
 
  1824 			}
 
  1819 		
  1825 		
  1820 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,25,signallingIndication);
 
  1826 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,25,signallingIndication);
 
  1821 		if(ret!=KErrNone)
 
  1827 		if(ret!=KErrNone)
 
  1822 			{
 
  1828 			{
 
  1823 			LOGPARSERR("QosProfileReqR5::signallingIndication",ret,25,&KQosProfileReqR5);
 
  1829 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_26, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::SIGNALLINGINDICATION returned %d (element no. %d) from tag %s.",ret,25,KQosProfileReqR5);
 
  1824 			continue;
 
  1830 			continue;
 
  1825 			}
 
  1831 			}
 
  1826 		else 
  1832 		else 
  1827 			{
 
  1833 			{
 
  1828 			profileReq5.iSignallingIndication= signallingIndication;
 
  1834 			profileReq5.iSignallingIndication= signallingIndication;
 
  1829 			}
 
  1835 			}
 
  1830 			
  1836 			
  1831 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,26,reqTSourceStatisticsDescriptor);
 
  1837 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,26,reqTSourceStatisticsDescriptor);
 
  1832 		if(ret!=KErrNone)
 
  1838 		if(ret!=KErrNone)
 
  1833 			{
 
  1839 			{
 
  1834 			LOGPARSERR("QosProfileReqR5::reqTSourceStatisticsDescriptor",ret,26,&KQosProfileReqR5);
 
  1840 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5REQPROFILESL_27, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILEREQR5::REQTSOURCESTATISTICSDESCRIPTOR returned %d (element no. %d) from tag %s.",ret,26,KQosProfileReqR5);
 
  1835 			continue;
 
  1841 			continue;
 
  1836 			}
 
  1842 			}
 
  1837 		else 
  1843 		else 
  1838 			{
 
  1844 			{
 
  1839 			if(AsciiToNum(reqTSourceStatisticsDescriptor, digit)==KErrNone)
 
  1845 			if(AsciiToNum(reqTSourceStatisticsDescriptor, digit)==KErrNone)
 
  1869  		TPtrC8 reqTSourceStatisticsDescriptor;
 
  1875  		TPtrC8 reqTSourceStatisticsDescriptor;
 
  1870 		 
  1876 		 
  1871 		TInt ret = CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextName);
 
  1877 		TInt ret = CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextName);
 
  1872 		if(ret!=KErrNone)
 
  1878 		if(ret!=KErrNone)
 
  1873 			{
 
  1879 			{
 
  1874 			LOGPARSERR("QosProfileNegR5::contextName",ret,0,&KQosProfileNegR5);
 
  1880 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NEGPROFILESL_1, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR5::CONTEXTNAME returned %d (element no. %d) from tag %s.",ret,0,KQosProfileNegR5);
 
  1875 			continue;
 
  1881 			continue;
 
  1876 			}
 
  1882 			}
 
  1877 		else
 
  1883 		else
 
  1878 			{
 
  1884 			{
 
  1879 			profileNeg5.iContextName.Copy(contextName);
 
  1885 			profileNeg5.iContextName.Copy(contextName);
 
  1880 			if (profileNeg5.iContextName.Match(iPacketContext->ContextName())==KErrNotFound)
 
  1886 			if (profileNeg5.iContextName.Match(iPacketContext->ContextName())==KErrNotFound)
 
  1881 				{
 
  1887 				{
 
  1882 				LOGPARSERR("QosProfileNegR5::contextName",KErrArgument,0,&KQosProfileNegR5);
 
  1888 				OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NEGPROFILESL_2, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR5::CONTEXTNAME returned %d (element no. %d) from tag %s.",KErrArgument,0,KQosProfileNegR5);
 
  1883 				continue;
 
  1889 				continue;
 
  1884 				}
 
  1890 				}
 
  1885 			}
 
  1891 			}
 
  1886 
  1892 
  1887 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,duration);
 
  1893 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,duration);
 
  1888 		if(ret!=KErrNone)
 
  1894 		if(ret!=KErrNone)
 
  1889 			{
 
  1895 			{
 
  1890 			LOGPARSERR("QosProfileNegR5::duration",ret,1,&KQosProfileNegR5);
 
  1896 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NEGPROFILESL_3, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR5::DURATION returned %d (element no. %d) from tag %s.",ret,1,KQosProfileNegR5);
 
  1891 			continue;
 
  1897 			continue;
 
  1892 			}
 
  1898 			}
 
  1893 		else
 
  1899 		else
 
  1894 			{
 
  1900 			{
 
  1895 			if(AsciiToNum(duration, digit)==KErrNone)
 
  1901 			if(AsciiToNum(duration, digit)==KErrNone)
 
  1897 			}
 
  1903 			}
 
  1898 
  1904 
  1899 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,negTraffic);
 
  1905 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,negTraffic);
 
  1900 		if(ret!=KErrNone)
 
  1906 		if(ret!=KErrNone)
 
  1901 			{
 
  1907 			{
 
  1902 			LOGPARSERR("QosProfileNegR5::negTraffic",ret,2,&KQosProfileNegR5);
 
  1908 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NEGPROFILESL_4, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR5::NEGTRAFFIC returned %d (element no. %d) from tag %s.",ret,2,KQosProfileNegR5);
 
  1903 			continue;
 
  1909 			continue;
 
  1904 			}
 
  1910 			}
 
  1905 		else
 
  1911 		else
 
  1906 			{
 
  1912 			{
 
  1907 			if(AsciiToNum(negTraffic, digit)==KErrNone)
 
  1913 			if(AsciiToNum(negTraffic, digit)==KErrNone)
 
  1909 			}
 
  1915 			}
 
  1910 
  1916 
  1911 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,negDeliveryOrder);
 
  1917 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,negDeliveryOrder);
 
  1912 		if(ret!=KErrNone)
 
  1918 		if(ret!=KErrNone)
 
  1913 			{
 
  1919 			{
 
  1914 			LOGPARSERR("QosProfileNegR5::negDeliveryOrder",ret,3,&KQosProfileNegR5);
 
  1920 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NEGPROFILESL_5, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR5::NEGDELIVERYORDER returned %d (element no. %d) from tag %s.",ret,3,KQosProfileNegR5);
 
  1915 			continue;
 
  1921 			continue;
 
  1916 			}
 
  1922 			}
 
  1917 		else
 
  1923 		else
 
  1918 			{
 
  1924 			{
 
  1919 			if(AsciiToNum(negDeliveryOrder, digit)==KErrNone)
 
  1925 			if(AsciiToNum(negDeliveryOrder, digit)==KErrNone)
 
  1921 			}
 
  1927 			}
 
  1922 
  1928 
  1923 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,negErroneousSDUDelivery);
 
  1929 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,negErroneousSDUDelivery);
 
  1924 		if(ret!=KErrNone)
 
  1930 		if(ret!=KErrNone)
 
  1925 			{
 
  1931 			{
 
  1926 			LOGPARSERR("QosProfileNegR5::negErroneousSDUDelivery",ret,4,&KQosProfileNegR5);
 
  1932 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NEGPROFILESL_6, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR5::NEGERRONEOUSSDUDELIVERY returned %d (element no. %d) from tag %s.",ret,4,KQosProfileNegR5);
 
  1927 			continue;
 
  1933 			continue;
 
  1928 			}
 
  1934 			}
 
  1929 		else
 
  1935 		else
 
  1930 			{
 
  1936 			{
 
  1931 			if(AsciiToNum(negErroneousSDUDelivery, digit)==KErrNone)
 
  1937 			if(AsciiToNum(negErroneousSDUDelivery, digit)==KErrNone)
 
  1933 			}
 
  1939 			}
 
  1934 
  1940 
  1935 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,negMaxSDUSize);
 
  1941 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,negMaxSDUSize);
 
  1936 		if(ret!=KErrNone)
 
  1942 		if(ret!=KErrNone)
 
  1937 			{
 
  1943 			{
 
  1938 			LOGPARSERR("QosProfileNegR5::negMaxSDUSize",ret,5,&KQosProfileNegR5);
 
  1944 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NEGPROFILESL_7, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR5::NEGMAXSDUSIZE returned %d (element no. %d) from tag %s.",ret,5,KQosProfileNegR5);
 
  1939 			continue;
 
  1945 			continue;
 
  1940 			}
 
  1946 			}
 
  1941 		else
 
  1947 		else
 
  1942 			{
 
  1948 			{
 
  1943 			profileNeg5.iNegMaxSDUSize =  negMaxSDUSize;
 
  1949 			profileNeg5.iNegMaxSDUSize =  negMaxSDUSize;
 
  1944 			}
 
  1950 			}
 
  1945 
  1951 
  1946 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,negBitErrorRatio);
 
  1952 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,negBitErrorRatio);
 
  1947 		if(ret!=KErrNone)
 
  1953 		if(ret!=KErrNone)
 
  1948 			{
 
  1954 			{
 
  1949 			LOGPARSERR("QosProfileNegR5::negBitErrorRatio",ret,6,&KQosProfileNegR5);
 
  1955 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NEGPROFILESL_8, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR5::NEGBITERRORRATIO returned %d (element no. %d) from tag %s.",ret,6,KQosProfileNegR5);
 
  1950 			continue;
 
  1956 			continue;
 
  1951 			}
 
  1957 			}
 
  1952 		else
 
  1958 		else
 
  1953 			{
 
  1959 			{
 
  1954 			if(AsciiToNum(negBitErrorRatio, digit)==KErrNone)
 
  1960 			if(AsciiToNum(negBitErrorRatio, digit)==KErrNone)
 
  1957 
  1963 
  1958 		
  1964 		
  1959 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,negSDUErrorRatio);
 
  1965 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,negSDUErrorRatio);
 
  1960 		if(ret!=KErrNone)
 
  1966 		if(ret!=KErrNone)
 
  1961 			{
 
  1967 			{
 
  1962 			LOGPARSERR("QosProfileNegR5::negSDUErrorRatio",ret,7,&KQosProfileNegR5);
 
  1968 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NEGPROFILESL_9, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR5::NEGSDUERRORRATIO returned %d (element no. %d) from tag %s.",ret,7,KQosProfileNegR5);
 
  1963 			continue;
 
  1969 			continue;
 
  1964 			}
 
  1970 			}
 
  1965 		else
 
  1971 		else
 
  1966 			{
 
  1972 			{
 
  1967 			if(AsciiToNum(negSDUErrorRatio, digit)==KErrNone)
 
  1973 			if(AsciiToNum(negSDUErrorRatio, digit)==KErrNone)
 
  1969 			}
 
  1975 			}
 
  1970 
  1976 
  1971 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,negTrafficHandlingPriority);
 
  1977 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,negTrafficHandlingPriority);
 
  1972 		if(ret!=KErrNone)
 
  1978 		if(ret!=KErrNone)
 
  1973 			{
 
  1979 			{
 
  1974 			LOGPARSERR("QosProfileNegR5::negTrafficHandlingPriority",ret,8,&KQosProfileNegR5);
 
  1980 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NEGPROFILESL_10, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR5::NEGTRAFFICHANDLINGPRIORITY returned %d (element no. %d) from tag %s.",ret,8,KQosProfileNegR5);
 
  1975 			continue;
 
  1981 			continue;
 
  1976 			}
 
  1982 			}
 
  1977 		else
 
  1983 		else
 
  1978 			{
 
  1984 			{
 
  1979 			if(AsciiToNum(negTrafficHandlingPriority, digit)==KErrNone)
 
  1985 			if(AsciiToNum(negTrafficHandlingPriority, digit)==KErrNone)
 
  1981 			}
 
  1987 			}
 
  1982 
  1988 
  1983 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,negTransferDelay);
 
  1989 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,negTransferDelay);
 
  1984 		if(ret!=KErrNone)
 
  1990 		if(ret!=KErrNone)
 
  1985 			{
 
  1991 			{
 
  1986 			LOGPARSERR("QosProfileNegR5::negTransferDelay",ret,9,&KQosProfileNegR5);
 
  1992 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NEGPROFILESL_11, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR5::NEGTRANSFERDELAY returned %d (element no. %d) from tag %s.",ret,9,KQosProfileNegR5);
 
  1987 			continue;
 
  1993 			continue;
 
  1988 			}
 
  1994 			}
 
  1989 		else
 
  1995 		else
 
  1990 			{
 
  1996 			{
 
  1991 			profileNeg5.iNegTransferDelay =  negTransferDelay;
 
  1997 			profileNeg5.iNegTransferDelay =  negTransferDelay;
 
  1992 			}
 
  1998 			}
 
  1993 
  1999 
  1994 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,negGuaranteedUpLinkBitRate);
 
  2000 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,negGuaranteedUpLinkBitRate);
 
  1995 		if(ret!=KErrNone)
 
  2001 		if(ret!=KErrNone)
 
  1996 			{
 
  2002 			{
 
  1997 			LOGPARSERR("QosProfileNegR5::negGuaranteedUpLinkBitRate",ret,10,&KQosProfileNegR5);
 
  2003 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NEGPROFILESL_12, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR5::NEGGUARANTEEDUPLINKBITRATE returned %d (element no. %d) from tag %s.",ret,10,KQosProfileNegR5);
 
  1998 			continue;
 
  2004 			continue;
 
  1999 			}
 
  2005 			}
 
  2000 		else
 
  2006 		else
 
  2001 			{
 
  2007 			{
 
  2002 			profileNeg5.iNegGuaranteedUpLinkBitRate =  negGuaranteedUpLinkBitRate;
 
  2008 			profileNeg5.iNegGuaranteedUpLinkBitRate =  negGuaranteedUpLinkBitRate;
 
  2003 			}
 
  2009 			}
 
  2004 
  2010 
  2005 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,negGuaranteedDownLinkBitRate);
 
  2011 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,negGuaranteedDownLinkBitRate);
 
  2006 		if(ret!=KErrNone)
 
  2012 		if(ret!=KErrNone)
 
  2007 			{
 
  2013 			{
 
  2008 			LOGPARSERR("QosProfileNegR5::negGuaranteedDownLinkBitRate",ret,11,&KQosProfileNegR5);
 
  2014 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NEGPROFILESL_13, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR5::NEGGUARANTEEDDOWNLINKBITRATE returned %d (element no. %d) from tag %s.",ret,11,KQosProfileNegR5);
 
  2009 			continue;
 
  2015 			continue;
 
  2010 			}
 
  2016 			}
 
  2011 		else
 
  2017 		else
 
  2012 			{
 
  2018 			{
 
  2013 			profileNeg5.iNegGuaranteedDownLinkBitRate =  negGuaranteedDownLinkBitRate;
 
  2019 			profileNeg5.iNegGuaranteedDownLinkBitRate =  negGuaranteedDownLinkBitRate;
 
  2014 			}
 
  2020 			}
 
  2015 
  2021 
  2016 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,12,negMaxUpLinkRate);
 
  2022 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,12,negMaxUpLinkRate);
 
  2017 		if(ret!=KErrNone)
 
  2023 		if(ret!=KErrNone)
 
  2018 			{
 
  2024 			{
 
  2019 			LOGPARSERR("QosProfileNegR5::negMaxUpLinkRate",ret,12,&KQosProfileNegR5);
 
  2025 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NEGPROFILESL_14, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR5::NEGMAXUPLINKRATE returned %d (element no. %d) from tag %s.",ret,12,KQosProfileNegR5);
 
  2020 			continue;
 
  2026 			continue;
 
  2021 			}
 
  2027 			}
 
  2022 		else
 
  2028 		else
 
  2023 			{
 
  2029 			{
 
  2024 			profileNeg5.iNegMaxUpLinkRate =  negMaxUpLinkRate;
 
  2030 			profileNeg5.iNegMaxUpLinkRate =  negMaxUpLinkRate;
 
  2025 			}
 
  2031 			}
 
  2026 
  2032 
  2027 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,13,negMaxDownLinkRate);
 
  2033 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,13,negMaxDownLinkRate);
 
  2028 		if(ret!=KErrNone)
 
  2034 		if(ret!=KErrNone)
 
  2029 			{
 
  2035 			{
 
  2030 			LOGPARSERR("QosProfileNegR5::negMaxDownLinkRate",ret,13,&KQosProfileNegR5);
 
  2036 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NEGPROFILESL_15, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR5::NEGMAXDOWNLINKRATE returned %d (element no. %d) from tag %s.",ret,13,KQosProfileNegR5);
 
  2031 			continue;
 
  2037 			continue;
 
  2032 			}
 
  2038 			}
 
  2033 		else
 
  2039 		else
 
  2034 			{
 
  2040 			{
 
  2035 			profileNeg5.iNegMaxDownLinkRate =  negMaxDownLinkRate;
 
  2041 			profileNeg5.iNegMaxDownLinkRate =  negMaxDownLinkRate;
 
  2036 			}
 
  2042 			}
 
  2037 		
  2043 		
  2038 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,14,signallingIndication);
 
  2044 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,14,signallingIndication);
 
  2039 		if(ret!=KErrNone)
 
  2045 		if(ret!=KErrNone)
 
  2040 			{
 
  2046 			{
 
  2041 			LOGPARSERR("QosProfileNegR5::signallingIndication",ret,14,&KQosProfileNegR5);
 
  2047 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NEGPROFILESL_16, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR5::SIGNALLINGINDICATION returned %d (element no. %d) from tag %s.",ret,14,KQosProfileNegR5);
 
  2042 			continue;
 
  2048 			continue;
 
  2043 			}
 
  2049 			}
 
  2044 		else
 
  2050 		else
 
  2045 			{
 
  2051 			{
 
  2046 			profileNeg5.iSignallingIndication =  signallingIndication;
 
  2052 			profileNeg5.iSignallingIndication =  signallingIndication;
 
  2047 			}
 
  2053 			}
 
  2048 			
  2054 			
  2049 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,15,reqTSourceStatisticsDescriptor);
 
  2055 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,15,reqTSourceStatisticsDescriptor);
 
  2050 		if(ret!=KErrNone)
 
  2056 		if(ret!=KErrNone)
 
  2051 			{
 
  2057 			{
 
  2052 			LOGPARSERR("QosProfileNegR5::reqTSourceStatisticsDescriptor",ret,15,&KQosProfileNegR5);
 
  2058 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NEGPROFILESL_17, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSPROFILENEGR5::REQTSOURCESTATISTICSDESCRIPTOR returned %d (element no. %d) from tag %s.",ret,15,KQosProfileNegR5);
 
  2053 			continue;
 
  2059 			continue;
 
  2054 			}
 
  2060 			}
 
  2055 		else
 
  2061 		else
 
  2056 			{
 
  2062 			{
 
  2057 			if(AsciiToNum(reqTSourceStatisticsDescriptor, digit)==KErrNone)
 
  2063 			if(AsciiToNum(reqTSourceStatisticsDescriptor, digit)==KErrNone)
 
  2099 		TPtrC8 reqTSourceStatisticsDescriptor;
 
  2105 		TPtrC8 reqTSourceStatisticsDescriptor;
 
  2100 
  2106 
  2101 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextName);
 
  2107 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextName);
 
  2102 		if(ret!=KErrNone)
 
  2108 		if(ret!=KErrNone)
 
  2103 			{
 
  2109 			{
 
  2104 			LOGPARSERR("qosR5NetworkNotification::contextName",ret,0,&KQosNetworkNotificationType);
 
  2110 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NETWORKNOTIFICATIONSL_1, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSR5NETWORKNOTIFICATION::CONTEXTNAME returned %d (element no. %d) from tag %s.",ret,0,KQosNetworkNotificationType);
 
  2105 			continue;
 
  2111 			continue;
 
  2106 			}
 
  2112 			}
 
  2107 		else
 
  2113 		else
 
  2108 			{
 
  2114 			{
 
  2109 			qosR5NetworkNotification.iContextName.Copy(contextName);
 
  2115 			qosR5NetworkNotification.iContextName.Copy(contextName);
 
  2110 			}
 
  2116 			}
 
  2111 
  2117 
  2112 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,duration);
 
  2118 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,duration);
 
  2113 		if(ret!=KErrNone)
 
  2119 		if(ret!=KErrNone)
 
  2114 			{
 
  2120 			{
 
  2115 			LOGPARSERR("qosR5NetworkNotification::duration",ret,1,&KQosNetworkNotificationType);
 
  2121 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NETWORKNOTIFICATIONSL_2, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSR5NETWORKNOTIFICATION::DURATION returned %d (element no. %d) from tag %s.",ret,1,KQosNetworkNotificationType);
 
  2116 			continue;
 
  2122 			continue;
 
  2117 			}
 
  2123 			}
 
  2118 		else
 
  2124 		else
 
  2119 			{
 
  2125 			{
 
  2120 			if(AsciiToNum(duration, digit)==KErrNone)
 
  2126 			if(AsciiToNum(duration, digit)==KErrNone)
 
  2122 			}
 
  2128 			}
 
  2123 
  2129 
  2124 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,negTraffic);
 
  2130 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,negTraffic);
 
  2125 		if(ret!=KErrNone)
 
  2131 		if(ret!=KErrNone)
 
  2126 			{
 
  2132 			{
 
  2127 			LOGPARSERR("qosR5NetworkNotification::negTraffic",ret,2,&KQosNetworkNotificationType);
 
  2133 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NETWORKNOTIFICATIONSL_3, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSR5NETWORKNOTIFICATION::NEGTRAFFIC returned %d (element no. %d) from tag %s.",ret,2,KQosNetworkNotificationType);
 
  2128 			continue;
 
  2134 			continue;
 
  2129 			}
 
  2135 			}
 
  2130 		else
 
  2136 		else
 
  2131 			{
 
  2137 			{
 
  2132 			if(AsciiToNum(negTraffic, digit)==KErrNone)
 
  2138 			if(AsciiToNum(negTraffic, digit)==KErrNone)
 
  2134 			}
 
  2140 			}
 
  2135 
  2141 
  2136 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,negDeliveryOrder);
 
  2142 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,negDeliveryOrder);
 
  2137 		if(ret!=KErrNone)
 
  2143 		if(ret!=KErrNone)
 
  2138 			{
 
  2144 			{
 
  2139 			LOGPARSERR("qosR5NetworkNotification::negDeliveryOrder",ret,3,&KQosNetworkNotificationType);
 
  2145 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NETWORKNOTIFICATIONSL_4, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSR5NETWORKNOTIFICATION::NEGDELIVERYORDER returned %d (element no. %d) from tag %s.",ret,3,KQosNetworkNotificationType);
 
  2140 			continue;
 
  2146 			continue;
 
  2141 			}
 
  2147 			}
 
  2142 		else
 
  2148 		else
 
  2143 			{
 
  2149 			{
 
  2144 			if(AsciiToNum(negDeliveryOrder, digit)==KErrNone)
 
  2150 			if(AsciiToNum(negDeliveryOrder, digit)==KErrNone)
 
  2146 			}
 
  2152 			}
 
  2147 
  2153 
  2148 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,negErroneousSDUDelivery);
 
  2154 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,negErroneousSDUDelivery);
 
  2149 		if(ret!=KErrNone)
 
  2155 		if(ret!=KErrNone)
 
  2150 			{
 
  2156 			{
 
  2151 			LOGPARSERR("qosR5NetworkNotification::negErroneousSDUDelivery",ret,4,&KQosNetworkNotificationType);
 
  2157 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NETWORKNOTIFICATIONSL_5, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSR5NETWORKNOTIFICATION::NEGERRONEOUSSDUDELIVERY returned %d (element no. %d) from tag %s.",ret,4,KQosNetworkNotificationType);
 
  2152 			continue;
 
  2158 			continue;
 
  2153 			}
 
  2159 			}
 
  2154 		else
 
  2160 		else
 
  2155 			{
 
  2161 			{
 
  2156 			if(AsciiToNum(negErroneousSDUDelivery, digit)==KErrNone)
 
  2162 			if(AsciiToNum(negErroneousSDUDelivery, digit)==KErrNone)
 
  2158 			}
 
  2164 			}
 
  2159 
  2165 
  2160 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,negMaxSDUSize);
 
  2166 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,negMaxSDUSize);
 
  2161 		if(ret!=KErrNone)
 
  2167 		if(ret!=KErrNone)
 
  2162 			{
 
  2168 			{
 
  2163 			LOGPARSERR("qosR5NetworkNotification::negMaxSDUSize",ret,5,&KQosNetworkNotificationType);
 
  2169 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NETWORKNOTIFICATIONSL_6, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSR5NETWORKNOTIFICATION::NEGMAXSDUSIZE returned %d (element no. %d) from tag %s.",ret,5,KQosNetworkNotificationType);
 
  2164 			continue;
 
  2170 			continue;
 
  2165 			}
 
  2171 			}
 
  2166 		else
 
  2172 		else
 
  2167 			{
 
  2173 			{
 
  2168 			qosR5NetworkNotification.iNegMaxSDUSize =  negMaxSDUSize;
 
  2174 			qosR5NetworkNotification.iNegMaxSDUSize =  negMaxSDUSize;
 
  2169 			}
 
  2175 			}
 
  2170 
  2176 
  2171 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,negBitErrorRatio);
 
  2177 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,negBitErrorRatio);
 
  2172 		if(ret!=KErrNone)
 
  2178 		if(ret!=KErrNone)
 
  2173 			{
 
  2179 			{
 
  2174 			LOGPARSERR("qosR5NetworkNotification::negBitErrorRatio",ret,6,&KQosNetworkNotificationType);
 
  2180 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NETWORKNOTIFICATIONSL_7, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSR5NETWORKNOTIFICATION::NEGBITERRORRATIO returned %d (element no. %d) from tag %s.",ret,6,KQosNetworkNotificationType);
 
  2175 			continue;
 
  2181 			continue;
 
  2176 			}
 
  2182 			}
 
  2177 		else
 
  2183 		else
 
  2178 			{
 
  2184 			{
 
  2179 			if(AsciiToNum(negBitErrorRatio, digit)==KErrNone)
 
  2185 			if(AsciiToNum(negBitErrorRatio, digit)==KErrNone)
 
  2181 			}
 
  2187 			}
 
  2182 
  2188 
  2183 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,negSDUErrorRatio);
 
  2189 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,negSDUErrorRatio);
 
  2184 		if(ret!=KErrNone)
 
  2190 		if(ret!=KErrNone)
 
  2185 			{
 
  2191 			{
 
  2186 			LOGPARSERR("qosR5NetworkNotification::negSDUErrorRatio",ret,7,&KQosNetworkNotificationType);
 
  2192 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NETWORKNOTIFICATIONSL_8, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSR5NETWORKNOTIFICATION::NEGSDUERRORRATIO returned %d (element no. %d) from tag %s.",ret,7,KQosNetworkNotificationType);
 
  2187 			continue;
 
  2193 			continue;
 
  2188 			}
 
  2194 			}
 
  2189 		else
 
  2195 		else
 
  2190 			{
 
  2196 			{
 
  2191 			if(AsciiToNum(negSDUErrorRatio, digit)==KErrNone)
 
  2197 			if(AsciiToNum(negSDUErrorRatio, digit)==KErrNone)
 
  2193 			}
 
  2199 			}
 
  2194 
  2200 
  2195 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,negTrafficHandlingPriority);
 
  2201 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,negTrafficHandlingPriority);
 
  2196 		if(ret!=KErrNone)
 
  2202 		if(ret!=KErrNone)
 
  2197 			{
 
  2203 			{
 
  2198 			LOGPARSERR("qosR5NetworkNotification::negTrafficHandlingPriority",ret,8,&KQosNetworkNotificationType);
 
  2204 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NETWORKNOTIFICATIONSL_9, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSR5NETWORKNOTIFICATION::NEGTRAFFICHANDLINGPRIORITY returned %d (element no. %d) from tag %s.",ret,8,KQosNetworkNotificationType);
 
  2199 			continue;
 
  2205 			continue;
 
  2200 			}
 
  2206 			}
 
  2201 		else
 
  2207 		else
 
  2202 			{
 
  2208 			{
 
  2203 			if(AsciiToNum(negTrafficHandlingPriority, digit)==KErrNone)
 
  2209 			if(AsciiToNum(negTrafficHandlingPriority, digit)==KErrNone)
 
  2205 			}
 
  2211 			}
 
  2206 
  2212 
  2207 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,negTransferDelay);
 
  2213 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,negTransferDelay);
 
  2208 		if(ret!=KErrNone)
 
  2214 		if(ret!=KErrNone)
 
  2209 			{
 
  2215 			{
 
  2210 			LOGPARSERR("qosR5NetworkNotification::negTransferDelay",ret,9,&KQosNetworkNotificationType);
 
  2216 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NETWORKNOTIFICATIONSL_10, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSR5NETWORKNOTIFICATION::NEGTRANSFERDELAY returned %d (element no. %d) from tag %s.",ret,9,KQosNetworkNotificationType);
 
  2211 			continue;
 
  2217 			continue;
 
  2212 			}
 
  2218 			}
 
  2213 		else
 
  2219 		else
 
  2214 			{
 
  2220 			{
 
  2215 			qosR5NetworkNotification.iNegTransferDelay =  negTransferDelay;
 
  2221 			qosR5NetworkNotification.iNegTransferDelay =  negTransferDelay;
 
  2216 			}
 
  2222 			}
 
  2217 
  2223 
  2218 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,negGuaranteedUpLinkBitRate);
 
  2224 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,negGuaranteedUpLinkBitRate);
 
  2219 		if(ret!=KErrNone)
 
  2225 		if(ret!=KErrNone)
 
  2220 			{
 
  2226 			{
 
  2221 			LOGPARSERR("qosR5NetworkNotification::negGuaranteedUpLinkBitRate",ret,10,&KQosNetworkNotificationType);
 
  2227 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NETWORKNOTIFICATIONSL_11, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSR5NETWORKNOTIFICATION::NEGGUARANTEEDUPLINKBITRATE returned %d (element no. %d) from tag %s.",ret,10,KQosNetworkNotificationType);
 
  2222 			continue;
 
  2228 			continue;
 
  2223 			}
 
  2229 			}
 
  2224 		else
 
  2230 		else
 
  2225 			{
 
  2231 			{
 
  2226 			qosR5NetworkNotification.iNegGuaranteedUpLinkBitRate =  negGuaranteedUpLinkBitRate;
 
  2232 			qosR5NetworkNotification.iNegGuaranteedUpLinkBitRate =  negGuaranteedUpLinkBitRate;
 
  2227 			}
 
  2233 			}
 
  2228 
  2234 
  2229 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,negGuaranteedDownLinkBitRate);
 
  2235 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,negGuaranteedDownLinkBitRate);
 
  2230 		if(ret!=KErrNone)
 
  2236 		if(ret!=KErrNone)
 
  2231 			{
 
  2237 			{
 
  2232 			LOGPARSERR("qosR5NetworkNotification::negGuaranteedDownLinkBitRate",ret,11,&KQosNetworkNotificationType);
 
  2238 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NETWORKNOTIFICATIONSL_12, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSR5NETWORKNOTIFICATION::NEGGUARANTEEDDOWNLINKBITRATE returned %d (element no. %d) from tag %s.",ret,11,KQosNetworkNotificationType);
 
  2233 			continue;
 
  2239 			continue;
 
  2234 			}
 
  2240 			}
 
  2235 		else
 
  2241 		else
 
  2236 			{
 
  2242 			{
 
  2237 			qosR5NetworkNotification.iNegGuaranteedDownLinkBitRate =  negGuaranteedDownLinkBitRate;
 
  2243 			qosR5NetworkNotification.iNegGuaranteedDownLinkBitRate =  negGuaranteedDownLinkBitRate;
 
  2238 			}
 
  2244 			}
 
  2239 
  2245 
  2240 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,12,negMaxUpLinkRate);
 
  2246 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,12,negMaxUpLinkRate);
 
  2241 		if(ret!=KErrNone)
 
  2247 		if(ret!=KErrNone)
 
  2242 			{
 
  2248 			{
 
  2243 			LOGPARSERR("qosR5NetworkNotification::negMaxUpLinkRate",ret,12,&KQosNetworkNotificationType);
 
  2249 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NETWORKNOTIFICATIONSL_13, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSR5NETWORKNOTIFICATION::NEGMAXUPLINKRATE returned %d (element no. %d) from tag %s.",ret,12,KQosNetworkNotificationType);
 
  2244 			continue;
 
  2250 			continue;
 
  2245 			}
 
  2251 			}
 
  2246 		else
 
  2252 		else
 
  2247 			{
 
  2253 			{
 
  2248 			qosR5NetworkNotification.iNegMaxUpLinkRate =  negMaxUpLinkRate;
 
  2254 			qosR5NetworkNotification.iNegMaxUpLinkRate =  negMaxUpLinkRate;
 
  2249 			}
 
  2255 			}
 
  2250 
  2256 
  2251 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,13,negMaxDownLinkRate);
 
  2257 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,13,negMaxDownLinkRate);
 
  2252 		if(ret!=KErrNone)
 
  2258 		if(ret!=KErrNone)
 
  2253 			{
 
  2259 			{
 
  2254 			LOGPARSERR("qosR5NetworkNotification::negMaxDownLinkRate",ret,13,&KQosNetworkNotificationType);
 
  2260 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NETWORKNOTIFICATIONSL_14, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSR5NETWORKNOTIFICATION::NEGMAXDOWNLINKRATE returned %d (element no. %d) from tag %s.",ret,13,KQosNetworkNotificationType);
 
  2255 			continue;
 
  2261 			continue;
 
  2256 			}
 
  2262 			}
 
  2257 		else
 
  2263 		else
 
  2258 			{
 
  2264 			{
 
  2259 			qosR5NetworkNotification.iNegMaxDownLinkRate = negMaxDownLinkRate;
 
  2265 			qosR5NetworkNotification.iNegMaxDownLinkRate = negMaxDownLinkRate;
 
  2260 			}
 
  2266 			}
 
  2261 			
  2267 			
  2262 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,14,signallingIndication);
 
  2268 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,14,signallingIndication);
 
  2263 		if(ret!=KErrNone)
 
  2269 		if(ret!=KErrNone)
 
  2264 			{
 
  2270 			{
 
  2265 			LOGPARSERR("qosR5NetworkNotification::signallingIndication",ret,14,&KQosNetworkNotificationType);
 
  2271 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NETWORKNOTIFICATIONSL_15, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSR5NETWORKNOTIFICATION::SIGNALLINGINDICATION returned %d (element no. %d) from tag %s.",ret,14,KQosNetworkNotificationType);
 
  2266 			continue;
 
  2272 			continue;
 
  2267 			}
 
  2273 			}
 
  2268 		else
 
  2274 		else
 
  2269 			{
 
  2275 			{
 
  2270 			qosR5NetworkNotification.iSignallingIndication =  signallingIndication;
 
  2276 			qosR5NetworkNotification.iSignallingIndication =  signallingIndication;
 
  2271 			}
 
  2277 			}
 
  2272 			
  2278 			
  2273 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,15,reqTSourceStatisticsDescriptor);
 
  2279 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,15,reqTSourceStatisticsDescriptor);
 
  2274 		if(ret!=KErrNone)
 
  2280 		if(ret!=KErrNone)
 
  2275 			{
 
  2281 			{
 
  2276 			LOGPARSERR("qosR5NetworkNotification::reqTSourceStatisticsDescriptor",ret,15,&KQosNetworkNotificationType);
 
  2282 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETR5NETWORKNOTIFICATIONSL_16, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSR5NETWORKNOTIFICATION::REQTSOURCESTATISTICSDESCRIPTOR returned %d (element no. %d) from tag %s.",ret,15,KQosNetworkNotificationType);
 
  2277 			continue;
 
  2283 			continue;
 
  2278 			}
 
  2284 			}
 
  2279 		else
 
  2285 		else
 
  2280 			{
 
  2286 			{
 
  2281 			if(AsciiToNum(reqTSourceStatisticsDescriptor, digit)==KErrNone)
 
  2287 			if(AsciiToNum(reqTSourceStatisticsDescriptor, digit)==KErrNone)
 
  2301  		{
 
  2307  		{
 
  2302  		TInt delay = 0;
 
  2308  		TInt delay = 0;
 
  2303 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,delay);
 
  2309 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,delay);
 
  2304 		if(ret!=KErrNone || delay < 0)
 
  2310 		if(ret!=KErrNone || delay < 0)
 
  2305 			{
 
  2311 			{
 
  2306 			LOGPARSERR("SetQoSDelay::delay",ret,0,&KSetQoSDelay);
 
  2312 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETSETQOSSETTINGS_1, "WARNING - CONFIGURATION FILE PARSING - Reading element SETQOSDELAY::DELAY returned %d (element no. %d) from tag %s.",ret,0,KSetQoSDelay);
 
  2307 			}
 
  2313 			}
 
  2308 		else
 
  2314 		else
 
  2309 			{
 
  2315 			{
 
  2310 			iSetQoSDelay = delay;
 
  2316 			iSetQoSDelay = delay;
 
  2311 			}
 
  2317 			}
 
  2312 			
  2318 			
  2313 		TInt at = 0;
 
  2319 		TInt at = 0;
 
  2314 		ret = CTestConfig::GetElement(item->Value(),KStdDelimiter,1,at);
 
  2320 		ret = CTestConfig::GetElement(item->Value(),KStdDelimiter,1,at);
 
  2315 		if(ret != KErrNone)
 
  2321 		if(ret != KErrNone)
 
  2316 			{
 
  2322 			{
 
  2317 			LOGPARSERR("SetQoSDelay::at",ret,1,&KSetQoSDelay);
 
  2323 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETSETQOSSETTINGS_2, "WARNING - CONFIGURATION FILE PARSING - Reading element SETQOSDELAY::AT returned %d (element no. %d) from tag %s.",ret,1,KSetQoSDelay);
 
  2318 			}
 
  2324 			}
 
  2319 		else
 
  2325 		else
 
  2320 			{
 
  2326 			{
 
  2321 			iSetQoSDelayAt = at;
 
  2327 			iSetQoSDelayAt = at;
 
  2322 			}
 
  2328 			}
 
  2329 * Trivial Destructor
 
  2335 * Trivial Destructor
 
  2330 * Closes all CObject type objects and destroys all other objects created in the ConstructL()
 
  2336 * Closes all CObject type objects and destroys all other objects created in the ConstructL()
 
  2331 *
 
  2337 *
 
  2332 */
 
  2338 */
 
  2333 	{
 
  2339 	{
 
  2334 	LOGPACKET1("CSimPacketQoS: Entered destructor");
 
  2340 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_DTOR_1, "CSimPacketQoS: Entered destructor");
 
  2335 
  2341 
  2336 	if (iProfiles != NULL)
 
  2342 	if (iProfiles != NULL)
 
  2337 	{
 
  2343 	{
 
  2338 		iProfiles->Delete(0,iProfiles->Count());
 
  2344 		iProfiles->Delete(0,iProfiles->Count());
 
  2339 		delete iProfiles;
 
  2345 		delete iProfiles;
 
  2460 */
 
  2466 */
 
  2461 	{
 
  2467 	{
 
  2462 	switch (aIpc)
 
  2468 	switch (aIpc)
 
  2463 		{
 
  2469 		{
 
  2464 		case EPacketQoSNotifyProfileChanged:
 
  2470 		case EPacketQoSNotifyProfileChanged:
 
  2465 			LOGPACKET1("CSimPacketQoS: RegisterNotification - Profile Changed");
 
  2471 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_REGISTERNOTIFICATION_1, "CSimPacketQoS: RegisterNotification - Profile Changed");
 
  2466 			return KErrNone;
 
  2472 			return KErrNone;
 
  2467 		default:
 
  2473 		default:
 
  2468 			// Unknown or invalid IPC
 
  2474 			// Unknown or invalid IPC
 
  2469 			LOGPACKET1("CSimPacketQoS: Register error, unknown IPC");
 
  2475 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_REGISTERNOTIFICATION_2, "CSimPacketQoS: Register error, unknown IPC");
 
  2470 			return KErrNotSupported;
 
  2476 			return KErrNotSupported;
 
  2471 		}
 
  2477 		}
 
  2472 	}
 
  2478 	}
 
  2473 
  2479 
  2474 TInt CSimPacketQoS::DeregisterNotification(const TInt aIpc)
 
  2480 TInt CSimPacketQoS::DeregisterNotification(const TInt aIpc)
 
  2485 */
 
  2491 */
 
  2486 	{
 
  2492 	{
 
  2487 	switch (aIpc)
 
  2493 	switch (aIpc)
 
  2488 		{
 
  2494 		{
 
  2489 		case EPacketQoSNotifyProfileChanged:
 
  2495 		case EPacketQoSNotifyProfileChanged:
 
  2490 			LOGPACKET1("CSimPacketQoS: DeregisterNotification - Profile Changed");
 
  2496 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_DEREGISTERNOTIFICATION_1, "CSimPacketQoS: DeregisterNotification - Profile Changed");
 
  2491 			return KErrNone;
 
  2497 			return KErrNone;
 
  2492 		default:
 
  2498 		default:
 
  2493 			// Unknown or invalid IPC
 
  2499 			// Unknown or invalid IPC
 
  2494 			LOGPACKET1("CSimPacketQoS: Deregister error, unknown IPC");
 
  2500 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_DEREGISTERNOTIFICATION_2, "CSimPacketQoS: Deregister error, unknown IPC");
 
  2495 			return KErrNotSupported;
 
  2501 			return KErrNotSupported;
 
  2496 		}
 
  2502 		}
 
  2497 	}
 
  2503 	}
 
  2498 
  2504 
  2499 TInt CSimPacketQoS::NumberOfSlotsL(const TInt aIpc)
 
  2505 TInt CSimPacketQoS::NumberOfSlotsL(const TInt aIpc)
 
  2508 	{
 
  2514 	{
 
  2509 	TInt numberOfSlots=1;
 
  2515 	TInt numberOfSlots=1;
 
  2510 	switch (aIpc)
 
  2516 	switch (aIpc)
 
  2511 		{
 
  2517 		{
 
  2512 		case EPacketQoSNotifyProfileChanged:
 
  2518 		case EPacketQoSNotifyProfileChanged:
 
  2513 			LOGPACKET1("CGprsDGprsTsy: Registered with 5 slots");
 
  2519 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_NUMBEROFSLOTSL_1, "CGprsDGprsTsy: Registered with 5 slots");
 
  2514 			numberOfSlots=5;
 
  2520 			numberOfSlots=5;
 
  2515 			break;
 
  2521 			break;
 
  2516 		default:
 
  2522 		default:
 
  2517 			// Unknown or invalid IPC
 
  2523 			// Unknown or invalid IPC
 
  2518 			LOGPACKET1("CSimPacketQoS: Number of Slots error, unknown IPC");
 
  2524 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_NUMBEROFSLOTSL_2, "CSimPacketQoS: Number of Slots error, unknown IPC");
 
  2519 			User::Leave(KErrNotSupported);
 
  2525 			User::Leave(KErrNotSupported);
 
  2520 			break;
 
  2526 			break;
 
  2521 		}  
  2527 		}  
  2522 	return numberOfSlots;
 
  2528 	return numberOfSlots;
 
  2523 	}
 
  2529 	}
 
  2555  				setQoSData.iData = aPackage.Des1n();
 
  2561  				setQoSData.iData = aPackage.Des1n();
 
  2556  
  2562  
  2557  				TRAPD(ret, iSetQoSData->AppendL(setQoSData) );
 
  2563  				TRAPD(ret, iSetQoSData->AppendL(setQoSData) );
 
  2558  				if (ret != KErrNone)
 
  2564  				if (ret != KErrNone)
 
  2559                  	{
 
  2565                  	{
 
  2560                  	LOGPACKET1("CSimPacketQoS::ExtFunc AppendL call fail");
 
  2566                  	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_EXTFUNC_1, "CSimPacketQoS::ExtFunc AppendL call fail");
 
  2561                  	return ret;
 
  2567                  	return ret;
 
  2562                  	}
 
  2568                  	}
 
  2563                  	
  2569                  	
  2564                iSetProfileCallCount++;		
  2570                iSetProfileCallCount++;		
  2565  				iSetQoSTimer->Start(iSetQoSDelay,this,ETimerIdPcktQoSSet);				
  2571  				iSetQoSTimer->Start(iSetQoSDelay,this,ETimerIdPcktQoSSet);				
  2610 * @param aTsyReqHandle  The request handle for completing the request 
  2616 * @param aTsyReqHandle  The request handle for completing the request 
  2611 * @param aIpc Ipc representing the request
 
  2617 * @param aIpc Ipc representing the request
 
  2612 * @return err KErrNone if request completes ok
 
  2618 * @return err KErrNone if request completes ok
 
  2613 */
 
  2619 */
 
  2614 	{
 
  2620 	{
 
  2615 	LOGPACKET1("CSimPacketQoS: - CancelService called");
 
  2621 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_CANCELSERVICE_1, "CSimPacketQoS: - CancelService called");
 
  2616 	switch (aIpc)
 
  2622 	switch (aIpc)
 
  2617 		{
 
  2623 		{
 
  2618 		case EPacketQoSSetProfileParams:
 
  2624 		case EPacketQoSSetProfileParams:
 
  2619 			return SetProfileCancel(aTsyReqHandle);
 
  2625 			return SetProfileCancel(aTsyReqHandle);
 
  2620 		case EPacketQoSGetProfileParams:
 
  2626 		case EPacketQoSGetProfileParams:
 
  2638 * @param aTsyReqHandle Tsy Request handle for the client request
 
  2644 * @param aTsyReqHandle Tsy Request handle for the client request
 
  2639 * @param aConfig pointer containing the parameters to set to.
 
  2645 * @param aConfig pointer containing the parameters to set to.
 
  2640 * @return KErrNone
 
  2646 * @return KErrNone
 
  2641 */
 
  2647 */
 
  2642 	{
 
  2648 	{
 
  2643 	LOGPACKET1("CSimPacketQoS::SetProfile called");
 
  2649 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_1, "CSimPacketQoS::SetProfile called");
 
  2644 	TPckg<TPacketDataConfigBase>* configBase = (TPckg<TPacketDataConfigBase>*)aConfig;
 
  2650 	TPckg<TPacketDataConfigBase>* configBase = (TPckg<TPacketDataConfigBase>*)aConfig;
 
  2645 	TPacketDataConfigBase& configBaseV1 = (*configBase)();
 
  2651 	TPacketDataConfigBase& configBaseV1 = (*configBase)();
 
  2646 
  2652 
  2647 	TInt err = KErrGeneral;
 
  2653 	TInt err = KErrGeneral;
 
  2648 
  2654 
  2701 				{
 
  2707 				{
 
  2702 				TProfileReqR99 profile = iReqR99Profiles->At(i);
 
  2708 				TProfileReqR99 profile = iReqR99Profiles->At(i);
 
  2703 
  2709 
  2704 				if (MatchContext(profile)==KErrNone)
 
  2710 				if (MatchContext(profile)==KErrNone)
 
  2705 					{
 
  2711 					{
 
  2706 					LOGPACKET1("====REQ QOS===");
 
  2712 					OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_2, "====REQ QOS===");
 
  2707 	
  2713 	
  2708 					
  2714 					
  2709 					
  2715 					
  2710 				//	LOGPACKET3("Req Traffic [%d] [%d]", qosConfigV1.iReqTrafficClass, profile.iReqTraffic);
 
  2716 				//	LOGPACKET3("Req Traffic [%d] [%d]", qosConfigV1.iReqTrafficClass, profile.iReqTraffic);
 
  2711 				//	LOGCOMMON3("Min Traffic [%d] [%d]", qosConfigV1.iMinTrafficClass, profile.iMinTraffic);
 
  2717 				//	LOGCOMMON3("Min Traffic [%d] [%d]", qosConfigV1.iMinTrafficClass, profile.iMinTraffic);
 
  2712 					LOGPACKET3("Req Del order [%d] [%d]",qosConfigV1.iReqDeliveryOrderReqd, profile.iReqDeliveryOrder);
 
  2718 					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_3, "Req Del order [%d] [%d]",qosConfigV1.iReqDeliveryOrderReqd, profile.iReqDeliveryOrder);
 
  2713 					LOGPACKET3("Min Del order [%d] [%d]",qosConfigV1.iMinDeliveryOrderReqd , profile.iMinDeliveryOrder);
 
  2719 					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_4, "Min Del order [%d] [%d]",qosConfigV1.iMinDeliveryOrderReqd , profile.iMinDeliveryOrder);
 
  2714 					LOGPACKET3("Req Del err SDU [%d] [%d]",qosConfigV1.iReqDeliverErroneousSDU , profile.iReqErroneousSDU);
 
  2720 					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_5, "Req Del err SDU [%d] [%d]",qosConfigV1.iReqDeliverErroneousSDU , profile.iReqErroneousSDU);
 
  2715 					LOGPACKET3("Min Del err SDU [%d] [%d]",qosConfigV1.iMinDeliverErroneousSDU , profile.iMinErroneousSDU);
 
  2721 					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_6, "Min Del err SDU [%d] [%d]",qosConfigV1.iMinDeliverErroneousSDU , profile.iMinErroneousSDU);
 
  2716  					LOGPACKET3("Max Sdu Size [%d] [%d]",qosConfigV1.iReqMaxSDUSize , profile.iMaxSDUSize);
 
  2722  					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_7, "Max Sdu Size [%d] [%d]",qosConfigV1.iReqMaxSDUSize , profile.iMaxSDUSize);
 
  2717  					LOGPACKET3("Min Sdu Size [%d] [%d]",qosConfigV1.iMinAcceptableMaxSDUSize , profile.iMinSDUSize);
 
  2723  					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_8, "Min Sdu Size [%d] [%d]",qosConfigV1.iMinAcceptableMaxSDUSize , profile.iMinSDUSize);
 
  2718   					LOGPACKET3("Req Down [%d] [%d]",qosConfigV1.iReqMaxRate.iDownlinkRate , profile.iReqDownLinkTBitRate);
 
  2724   					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_9, "Req Down [%d] [%d]",qosConfigV1.iReqMaxRate.iDownlinkRate , profile.iReqDownLinkTBitRate);
 
  2719   					LOGPACKET3("Req Up [%d] [%d]", qosConfigV1.iReqMaxRate.iUplinkRate , profile.iReqUpLinkTBitRate);
 
  2725   					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_10, "Req Up [%d] [%d]", qosConfigV1.iReqMaxRate.iUplinkRate , profile.iReqUpLinkTBitRate);
 
  2720 					LOGPACKET3("Min Guar Down[%d] [%d]",qosConfigV1.iMinGuaranteedRate.iDownlinkRate , profile.iMinGuaranteedDownLinkTBitRate);
 
  2726 					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_11, "Min Guar Down[%d] [%d]",qosConfigV1.iMinGuaranteedRate.iDownlinkRate , profile.iMinGuaranteedDownLinkTBitRate);
 
  2721 					LOGPACKET3("Min Guar Up [%d] [%d]",qosConfigV1.iMinGuaranteedRate.iUplinkRate , profile.iMinGuaranteedUpLinkTBitRate);
 
  2727 					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_12, "Min Guar Up [%d] [%d]",qosConfigV1.iMinGuaranteedRate.iUplinkRate , profile.iMinGuaranteedUpLinkTBitRate);
 
  2722 					LOGPACKET3("Req BER [%d] [%d]",qosConfigV1.iReqBER , profile.iReqTBitErrorRatio);
 
  2728 					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_13, "Req BER [%d] [%d]",qosConfigV1.iReqBER , profile.iReqTBitErrorRatio);
 
  2723 					LOGPACKET3("Max BER [%d] [%d]",qosConfigV1.iMaxBER , profile.iMinTBitErrorRatio);
 
  2729 					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_14, "Max BER [%d] [%d]",qosConfigV1.iMaxBER , profile.iMinTBitErrorRatio);
 
  2724 					LOGPACKET3("Req SDU err ratio [%d] [%d]",qosConfigV1.iReqSDUErrorRatio , profile.iReqTSDUErrorRatio);
 
  2730 					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_15, "Req SDU err ratio [%d] [%d]",qosConfigV1.iReqSDUErrorRatio , profile.iReqTSDUErrorRatio);
 
  2725 					LOGPACKET3("Max SDU err ration [%d] [%d]",qosConfigV1.iMaxSDUErrorRatio , profile.iMinTSDUErrorRatio);
 
  2731 					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_16, "Max SDU err ration [%d] [%d]",qosConfigV1.iMaxSDUErrorRatio , profile.iMinTSDUErrorRatio);
 
  2726 					LOGPACKET3("Req Traffic Handling priority [%d] [%d]",qosConfigV1.iReqTrafficHandlingPriority , profile.iReqTTrafficHandlingPriority);
 
  2732 					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_17, "Req Traffic Handling priority [%d] [%d]",qosConfigV1.iReqTrafficHandlingPriority , profile.iReqTTrafficHandlingPriority);
 
  2727 					LOGPACKET3("Min Traffic Handling priority [%d] [%d]",qosConfigV1.iMinTrafficHandlingPriority , profile.iMinTTrafficHandlingPriority);
 
  2733 					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_18, "Min Traffic Handling priority [%d] [%d]",qosConfigV1.iMinTrafficHandlingPriority , profile.iMinTTrafficHandlingPriority);
 
  2728 					LOGPACKET3("Req Transfer Delay [%d] [%d]",qosConfigV1.iReqTransferDelay , profile.iReqTransferDelay);
 
  2734 					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_19, "Req Transfer Delay [%d] [%d]",qosConfigV1.iReqTransferDelay , profile.iReqTransferDelay);
 
  2729 					LOGPACKET3("Max Transfer Delay [%d] [%d]",qosConfigV1.iMaxTransferDelay , profile.iMinTransferDelay);
 
  2735 					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_20, "Max Transfer Delay [%d] [%d]",qosConfigV1.iMaxTransferDelay , profile.iMinTransferDelay);
 
  2730 					LOGPACKET3("Req Guar downlink bitrate [%d] [%d]",qosConfigV1.iReqGuaranteedRate.iDownlinkRate , profile.iReqGuaranteedDownLinkTBitRate);
 
  2736 					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_21, "Req Guar downlink bitrate [%d] [%d]",qosConfigV1.iReqGuaranteedRate.iDownlinkRate , profile.iReqGuaranteedDownLinkTBitRate);
 
  2731 					LOGPACKET3("Req Guar uplink bitrate [%d] [%d]",qosConfigV1.iReqGuaranteedRate.iUplinkRate , profile.iReqGuaranteedUpLinkTBitRate);
 
  2737 					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_22, "Req Guar uplink bitrate [%d] [%d]",qosConfigV1.iReqGuaranteedRate.iUplinkRate , profile.iReqGuaranteedUpLinkTBitRate);
 
  2732 					LOGPACKET3("Min Guar downlink [%d] [%d]",qosConfigV1.iMinGuaranteedRate.iDownlinkRate , profile.iMinGuaranteedDownLinkTBitRate);
 
  2738 					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_23, "Min Guar downlink [%d] [%d]",qosConfigV1.iMinGuaranteedRate.iDownlinkRate , profile.iMinGuaranteedDownLinkTBitRate);
 
  2733 					LOGPACKET3("Min Guar uplink  [%d] [%d]",qosConfigV1.iMinGuaranteedRate.iUplinkRate , profile.iMinGuaranteedUpLinkTBitRate);
 
  2739 					OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILE_24, "Min Guar uplink  [%d] [%d]",qosConfigV1.iMinGuaranteedRate.iUplinkRate , profile.iMinGuaranteedUpLinkTBitRate);
 
  2734 						
  2740 						
  2735 					
  2741 					
  2736 					
  2742 					
  2737 					
  2743 					
  2738 					
  2744 					
  2859 * Cancels the Setconfig request.
 
  2865 * Cancels the Setconfig request.
 
  2860 *
 
  2866 *
 
  2861 * @param aTsyReqHandle Tsy Request handle for the client request
 
  2867 * @param aTsyReqHandle Tsy Request handle for the client request
 
  2862 * @return err KErrNone 
  2868 * @return err KErrNone 
  2863 */
 
  2869 */
 
  2864 	LOGPACKET1("CSimPacketQoS::SetProfileCancel called");
 
  2870 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_SETPROFILECANCEL_1, "CSimPacketQoS::SetProfileCancel called");
 
  2865 	
  2871 	
  2866 	TInt index  = 0;
 
  2872 	TInt index  = 0;
 
  2867 	if (TSetQoSData::Find(iSetQoSData, aTsyReqHandle, index) == KErrNone)
 
  2873 	if (TSetQoSData::Find(iSetQoSData, aTsyReqHandle, index) == KErrNone)
 
  2868 		{
 
  2874 		{
 
  2869 		iSetQoSData->Delete(index);
 
  2875 		iSetQoSData->Delete(index);
 
  2889 * @param aTsyReqHandle Tsy Request handle for the client request
 
  2895 * @param aTsyReqHandle Tsy Request handle for the client request
 
  2890 * @param aConfig pointer containing the parameters to Get to.
 
  2896 * @param aConfig pointer containing the parameters to Get to.
 
  2891 * @return KErrNone
 
  2897 * @return KErrNone
 
  2892 */
 
  2898 */
 
  2893 	{
 
  2899 	{
 
  2894 	LOGPACKET1("CSimPacketQoS::GetProfile called");
 
  2900 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETPROFILE_1, "CSimPacketQoS::GetProfile called");
 
  2895 	TPckg<TPacketDataConfigBase>* configBase = (TPckg<TPacketDataConfigBase>*)aConfig;
 
  2901 	TPckg<TPacketDataConfigBase>* configBase = (TPckg<TPacketDataConfigBase>*)aConfig;
 
  2896 	TPacketDataConfigBase& configBaseV1 = (*configBase)();
 
  2902 	TPacketDataConfigBase& configBaseV1 = (*configBase)();
 
  2897 	
  2903 	
  2898 	// GPRS
 
  2904 	// GPRS
 
  2899 	if(configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigGPRS)
 
  2905 	if(configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigGPRS)
 
  3122 *
 
  3128 *
 
  3123 * @param aTsyReqHandle Tsy Request handle for the client cancel request
 
  3129 * @param aTsyReqHandle Tsy Request handle for the client cancel request
 
  3124 * @return KErrNone
 
  3130 * @return KErrNone
 
  3125 */
 
  3131 */
 
  3126 	{
 
  3132 	{
 
  3127 	LOGPACKET1("CSimPacketQoS::GetProfileCancel called");
 
  3133 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETPROFILECANCEL_1, "CSimPacketQoS::GetProfileCancel called");
 
  3128 	return KErrNone;
 
  3134 	return KErrNone;
 
  3129 	}
 
  3135 	}
 
  3130 
  3136 
  3131 TInt CSimPacketQoS::GetProfileCaps(const TTsyReqHandle aTsyReqHandle,TDes8* aConfig)
 
  3137 TInt CSimPacketQoS::GetProfileCaps(const TTsyReqHandle aTsyReqHandle,TDes8* aConfig)
 
  3132 /**
 
  3138 /**
 
  3138 * @param aTsyReqHandle Tsy Request handle for the client request
 
  3144 * @param aTsyReqHandle Tsy Request handle for the client request
 
  3139 * @param aConfig pointer containing the parameters to Get to.
 
  3145 * @param aConfig pointer containing the parameters to Get to.
 
  3140 * @return KErrNone
 
  3146 * @return KErrNone
 
  3141 */
 
  3147 */
 
  3142 	{
 
  3148 	{
 
  3143 	LOGPACKET1("CSimPacketQoS::GetProfileCaps called");
 
  3149 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETPROFILECAPS_1, "CSimPacketQoS::GetProfileCaps called");
 
  3144 	TPckg<TPacketDataConfigBase>* configBase = (TPckg<TPacketDataConfigBase>*)aConfig;
 
  3150 	TPckg<TPacketDataConfigBase>* configBase = (TPckg<TPacketDataConfigBase>*)aConfig;
 
  3145 	TPacketDataConfigBase& configBaseV1 = (*configBase)();
 
  3151 	TPacketDataConfigBase& configBaseV1 = (*configBase)();
 
  3146 
  3152 
  3147 	// GPRS
 
  3153 	// GPRS
 
  3148 	if(configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigGPRS)
 
  3154 	if(configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigGPRS)
 
  3197 *
 
  3203 *
 
  3198 * @param aTsyReqHandle Tsy Request handle for the client cancel request
 
  3204 * @param aTsyReqHandle Tsy Request handle for the client cancel request
 
  3199 * @return KErrNone
 
  3205 * @return KErrNone
 
  3200 */
 
  3206 */
 
  3201 	{
 
  3207 	{
 
  3202 	LOGPACKET1("CSimPacketQoS::GetProfileCapsCancel called");
 
  3208 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_GETPROFILECAPSCANCEL_1, "CSimPacketQoS::GetProfileCapsCancel called");
 
  3203 	return KErrNone;
 
  3209 	return KErrNone;
 
  3204 	}
 
  3210 	}
 
  3205 
  3211 
  3206 TInt CSimPacketQoS::NotifyProfileChanged(const TTsyReqHandle aTsyReqHandle, TDes8* aConfig)
 
  3212 TInt CSimPacketQoS::NotifyProfileChanged(const TTsyReqHandle aTsyReqHandle, TDes8* aConfig)
 
  3207 /**
 
  3213 /**
 
  3300 * 
  3306 * 
  3301 * @param aTsyReqHandle Tsy Request handle for the client cancel request
 
  3307 * @param aTsyReqHandle Tsy Request handle for the client cancel request
 
  3302 * @return KErrNone
 
  3308 * @return KErrNone
 
  3303 */
 
  3309 */
 
  3304 {
 
  3310 {
 
  3305 	LOGPACKET1("CSimPacketQoS::NotifyProfileChangedCancel called");
 
  3311 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMPACKETQOS_NOTIFYPROFILECHANGEDCANCEL_1, "CSimPacketQoS::NotifyProfileChangedCancel called");
 
  3306 	if(iNotifyProfileGPRS.iNotifyPending &&	iNotifyProfileGPRS.iNotifyHandle == aTsyReqHandle)
 
  3312 	if(iNotifyProfileGPRS.iNotifyPending &&	iNotifyProfileGPRS.iNotifyHandle == aTsyReqHandle)
 
  3307 		{
 
  3313 		{
 
  3308 		iNotifyProfileGPRS.iNotifyPending=EFalse;
 
  3314 		iNotifyProfileGPRS.iNotifyPending=EFalse;
 
  3309 		ReqCompleted(aTsyReqHandle,KErrCancel);
 
  3315 		ReqCompleted(aTsyReqHandle,KErrCancel);
 
  3310 		}
 
  3316 		}
MCL/sf/os/cellularsrv