MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/ossrv/genericservices/httputils/Test/t_uriparser/CSipUriAndAuthorityTest.cpp
author sl@SLION-WIN7.fritz.box
Fri, 15 Jun 2012 03:10:57 +0200
changeset 0 bde4ae8d615e
permissions -rw-r--r--
First public contribution. 
     1 // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

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

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include "CSipUriAndAuthorityTest.h"

    17 #include "CUriAndAuthorityTest.h"

    18 #include <uriutilscommon.h>

    19 #include "SipUriAndAuthorityTests.h"

    20 

    21 #include <e32base.h>

    22 #include <f32file.h>

    23 

    24 CSipUriAndAuthorityTest* CSipUriAndAuthorityTest::NewLC(CIpuTestHarness* aTestHarness)

    25 	{

    26 	CSipUriAndAuthorityTest* self = new (ELeave) CSipUriAndAuthorityTest(aTestHarness);

    27 	CleanupStack::PushL(self);

    28 	self->ConstructL();

    29 	return self;

    30 	}

    31 

    32 CSipUriAndAuthorityTest* CSipUriAndAuthorityTest::NewL(CIpuTestHarness* aTestHarness)

    33 	{

    34 	CSipUriAndAuthorityTest* self = CSipUriAndAuthorityTest::NewLC(aTestHarness);

    35 	CleanupStack::Pop(self);

    36 	return self;

    37 	}

    38 

    39 CSipUriAndAuthorityTest::CSipUriAndAuthorityTest(CIpuTestHarness* aTestHarness)

    40 : iTestHarness(aTestHarness)

    41 	{

    42 	}

    43 

    44 void CSipUriAndAuthorityTest::ConstructL()

    45 	{

    46 	}

    47 

    48 CSipUriAndAuthorityTest::~CSipUriAndAuthorityTest()

    49 	{

    50 	}

    51 

    52 //

    53 //

    54 //	SIP Uri tests

    55 //

    56 //

    57 void CSipUriAndAuthorityTest::DoTestsL()

    58 	{

    59 	//allredy pushed

    60 	CUriAndAuthorityTest* uriAndAuthorityTest = CUriAndAuthorityTest::NewLC(iTestHarness);

    61 

    62 	// Test Sips TUriParser Component Extraction

    63 	uriAndAuthorityTest->TestUriComponentExtractionL(KCompsSip0, KSchemeSip0, KUserInfoSip0, KHostSip0, KPortSip0, KPathSip0, KQuerySip0, KFragmentSip0);

    64 	uriAndAuthorityTest->TestUriComponentExtractionL(KCompsSip1, KSchemeSip1, KUserInfoSip1, KHostSip1, KPortSip1, KPathSip1, KQuerySip1, KFragmentSip1);

    65 	uriAndAuthorityTest->TestUriComponentExtractionL(KCompsSip2, KSchemeSip2, KUserInfoSip2, KHostSip2, KPortSip2, KPathSip2, KQuerySip2, KFragmentSip2);

    66 	uriAndAuthorityTest->TestUriComponentExtractionL(KCompsSip3, KSchemeSip3, KUserInfoSip3, KHostSip3, KPortSip3, KPathSip3, KQuerySip3, KFragmentSip3);

    67 	uriAndAuthorityTest->TestUriComponentExtractionL(KCompsSip4, KSchemeSip4, KUserInfoSip4, KHostSip4, KPortSip4, KPathSip4, KQuerySip4, KFragmentSip4);

    68 	uriAndAuthorityTest->TestUriComponentExtractionL(KCompsSip5, KSchemeSip5, KUserInfoSip5, KHostSip5, KPortSip5, KPathSip5, KQuerySip5, KFragmentSip5);		

    69 	

    70 	// Sip URI construction test

    71 	uriAndAuthorityTest->TestUriSetComponentL(KSipUri_Scheme0, KSipUri_Host0, KSipUri_Userinfo0, KSipUri_Port0, KSipUri_Path0, KSipUri_Query0, KSipUri_Fragment0,

    72 		KSipUri_SchemeComp0, KSipUri_HostComp0, KSipUri_UserinfoComp0, KSipUri_PortComp0, KSipUri_PathComp0, KSipUri_QueryComp0, KSipUri_FragmentComp0);

    73 	

    74 /** No Fragment part exist in Sip Uri's as per RFC3261

    75 	// Sip URI destruction test

    76 	uriAndAuthorityTest->TestUriRemoveComponentL(KSipUri_NoScheme0, KSipUri_NoHost0, KSipUri_NoUserinfo0, KSipUri_NoPort0, KSipUri_NoPath0,

    77 		KSipUri_NoQuery0, KSipUri_NoFragment0, KSipUri_Whole0);

    78 */

    79 	// Same test as above, but with an IPv6 format host

    80 	// Sip URI construction test

    81 	uriAndAuthorityTest->TestUriSetComponentL(KSipUri_Scheme0, KSipUri_IPv6Host0, KSipUri_IPv6UserInfo0, KSipUri_IPv6Port0, KSipUri_IPv6Path0, KSipUri_IPv6Query0, KSipUri_IPv6Fragment0,

    82 		KSipUri_SchemeComp0, KUri_IPv6HostComp, KSipUri_UserinfoComp0, KSipUri_PortComp0, KSipUri_PathComp0, KSipUri_QueryComp0, KSipUri_FragmentComp0);

    83 

    84 /** No Fragment part exist in Sip Uri's as per RFC3261

    85 	// Sip URI destruction test

    86 	uriAndAuthorityTest->TestUriRemoveComponentL(KSipUri_IPv6NoScheme0, KSipUri_IPv6NoHost0, KSipUri_IPv6NoUserinfo0, KSipUri_IPv6NoPort0, KSipUri_IPv6NoPath0,

    87 		KSipUri_IPv6NoQuery0, KSipUri_IPv6NoFragment0, KSipUri_IPv6Whole0);

    88 */	

    89 	CleanupStack::PopAndDestroy(uriAndAuthorityTest);

    90 	

    91 	//Sip URI validation

    92 	TInt error=KErrNone;

    93 	error=OpenSipURIFile();

    94 	if (KErrNone!=error)

    95 		{

    96 		iTestHarness->StartTestL(_L("Test TUriParser Component "));

    97 		SipLogError(error, KCompsSipUriFileSystemError);

    98 		}

    99 	else

   100 		{

   101 		error=SipUriValidationL();		

   102 	   	if (KErrNone!=error)

   103 			{

   104 			iTestHarness->StartTestL(_L("Test TUriParser Component Validation "));

   105 			switch (error)

   106 				{

   107 			case KErrNotFound:

   108 				{

   109 				iTestHarness->LogIt(KCompsSipUriNoValidate);	

   110 				}

   111 				break;

   112 			case KErrBadName:

   113 				{

   114 				iTestHarness->LogIt(KCompsSipUriNoValidateData);

   115 				}

   116 				break;

   117 			default:

   118 				break;

   119 				}

   120 			iTestHarness->EndTest(KErrNone);	

   121 			}	

   122 		

   123 		if (iFoundEquivalence)

   124 			{

   125 			error=SipUriEquivalenceL();

   126 			//No Sip URI Equivalence data

   127 			if (KErrBadName==error)

   128 				{

   129 				iTestHarness->StartTestL(_L("Test TUriParser Component Equivalence "));

   130 				iTestHarness->LogIt(KCompsSipUriNoEquivalenceData);

   131 				iTestHarness->EndTest(KErrNone);

   132 				}

   133 			}

   134 		else

   135 			{

   136 			iTestHarness->StartTestL(_L("Test TUriParser Component Equivalence "));

   137 			iTestHarness->LogIt(KCompsSipUriNoEquivalence);

   138 			iTestHarness->EndTest(KErrNone);

   139 			error=KErrNone;

   140 			}

   141 		iFsSession.Close();

   142 		}

   143 	}

   144 	

   145 //

   146 //

   147 //	Open SIP Uri data file

   148 //

   149 //

   150 TInt CSipUriAndAuthorityTest::OpenSipURIFile()

   151 	{

   152 	RFile file;

   153 	TInt error=KErrNone;

   154 

   155 	error = iFsSession.Connect();

   156 	if (KErrNone!=error)

   157 		{

   158 		return error;			

   159 		}

   160 		

   161 	error = file.Open(iFsSession, KCompsSipUriFileName, EFileRead);

   162 	if (KErrNone!=error)

   163 		{

   164 		iFsSession.Close();

   165 		return error;			

   166 		}

   167 

   168 	iTUriParserFile.Set(file);

   169 	return error;

   170 	}

   171 	

   172 //

   173 //

   174 //	SIP Uri Logger

   175 //

   176 //

   177 void CSipUriAndAuthorityTest::SipLogError(TInt aError, const TDesC16& aSipUri) const

   178 	{

   179 	TBool wrongError=EFalse;

   180 	

   181 	//compare the Equivalent SIP URI to look for the correct error, these SIP URIs must be in T_UriParserSipUri.txt

   182 	//All equal

   183 	if (0==aSipUri.Compare(KCompsSipUriEqual0) && KErrNone != aError 

   184 		|| 0==aSipUri.Compare(KCompsSipUriEqual1) && KErrNone != aError 

   185 		|| 0==aSipUri.Compare(KCompsSipUriEqual2) && KErrNone != aError)

   186 		{

   187 		iTestHarness->LogIt(KCompsSipUriValidMess0);

   188 		wrongError=ETrue;

   189 		}

   190 	//All not equal		

   191 	if (0==aSipUri.Compare(KCompsSipUriNotEqual0) && KUriUtilsErrDifferentUserInfo == aError 

   192 		|| 0==aSipUri.Compare(KCompsSipUriNotEqual1) && KUriUtilsErrDifferentPath  == aError 

   193 		|| 0==aSipUri.Compare(KCompsSipUriNotEqual2) && KUriUtilsErrDifferentPort  == aError )

   194 		{

   195 		iTestHarness->LogIt(KCompsSipUriEqualMess1);

   196 		}

   197 

   198 	//compare the SIP URIs to look for the correct error returned by CUri for validation

   199 	if (0==aSipUri.Compare(KCompsSipUriNotEqual1) && KUriUtilsErrDifferentPath  != aError )

   200 		{

   201 		iTestHarness->LogIt(KCompsSipUriInvalidMess9);

   202 		wrongError=ETrue;

   203 		}

   204 

   205 

   206 	if (0==aSipUri.Compare(KCompsSipUriValid0) && KErrNone!= aError

   207 		|| 0==aSipUri.Compare(KCompsSipUriValid1) && KErrNone!= aError)

   208 		{

   209 		iTestHarness->LogIt(KCompsSipUriValidMess0);

   210 		wrongError=ETrue;

   211 		}

   212 

   213 	if (0==aSipUri.Compare(KCompsSipUriInvalid0) && KErrNotSupported != aError)

   214 		{

   215 		iTestHarness->LogIt(KCompsSipUriInvalidMess0);

   216 		wrongError=ETrue;

   217 		}

   218 	

   219 	if( 0==aSipUri.Compare(KCompsSipUriInvalid5) && KUriUtilsErrInvalidParam!= aError

   220 		|| 0==aSipUri.Compare(KCompsSipUriInvalid6) && KUriUtilsErrInvalidParam!= aError)

   221 		{

   222 		iTestHarness->LogIt(KCompsSipUriInvalidMess1);

   223 		wrongError=ETrue;

   224 		}

   225 	

   226 	if (0==aSipUri.Compare(KCompsSipUriInvalid3) && KUriUtilsErrInvalidHost!= aError)

   227 		{

   228 		iTestHarness->LogIt(KCompsSipUriInvalidMess2);

   229 		wrongError=ETrue;

   230 		}

   231 		

   232 	if (0==aSipUri.Compare(KCompsSipUriInvalid2) && KUriUtilsErrInvalidHeaders != aError)

   233 		{

   234 		iTestHarness->LogIt(KCompsSipUriInvalidMess8);

   235 		wrongError=ETrue;

   236 		}

   237 

   238 	if (0==aSipUri.Compare(KCompsSipUriInvalid1) && KUriUtilsErrInvalidPort != aError

   239 		|| 0==aSipUri.Compare(KCompsSipUriInvalid4) && KUriUtilsErrInvalidPort!= aError

   240 		|| 0==aSipUri.Compare(KCompsSipUriNotEqual2) && KUriUtilsErrDifferentPort  != aError)

   241 		{

   242 		iTestHarness->LogIt(KCompsSipUriInvalidMess3);

   243 		wrongError=ETrue;

   244 		}

   245 

   246 	if (0==aSipUri.Compare(KCompsSipUriInvalid7) && KUriUtilsErrInvalidUserInfo!= aError

   247 		|| 0==aSipUri.Compare(KCompsSipUriNotEqual0) && KUriUtilsErrDifferentUserInfo != aError)

   248 		{

   249 		iTestHarness->LogIt(KCompsSipUriInvalidMess7);

   250 		wrongError=ETrue;

   251 		}

   252 

   253 	if (wrongError)

   254 		{

   255 		iTestHarness->LogIt(KCompsSipUriInvalidMess5);

   256 		}

   257 	

   258 	LogErrorMessage(aSipUri, aError);

   259 	

   260 	if (wrongError)

   261 		{

   262 		iTestHarness->EndTest(aError);

   263 		}		

   264 	else

   265 		{

   266 		iTestHarness->EndTest(KErrNone);	

   267 		}

   268 	}

   269 

   270 //

   271 //

   272 //	SIP Uri Validation Test

   273 //

   274 //

   275 TInt CSipUriAndAuthorityTest::SipUriValidationL()

   276 	{

   277 	TBuf<256> data;

   278 	TInt error=KErrNone;

   279 	iFoundEquivalence=EFalse;

   280 	

   281 	//read the Valid section name in

   282 	error=iTUriParserFile.Read(data);

   283 	while(0!=data.Compare(KCompsSipUriValidate) && KErrNone==error)

   284 		{

   285 		if (0==data.Compare(KCompsSipUriEquivalence))

   286 			{

   287 			iFoundEquivalence=ETrue;

   288 			break;

   289 			}

   290 		data.Zero();

   291 		error=iTUriParserFile.Read(data);

   292 		}

   293 		

   294 	//No Validate Section, KErrEof

   295 	if (0!=data.Compare(KCompsSipUriValidate))

   296 		{

   297 		return KErrNotFound;

   298 		}

   299 	

   300 	//get the validation Data

   301 	error=iTUriParserFile.Read(data);

   302 	

   303 	//no data

   304 	if (KErrEof==error)

   305 		{

   306 		return KErrBadName;

   307 		}	

   308 	

   309 	//found Equivalence

   310 	if (0==data.Compare(KCompsSipUriEquivalence))

   311 		{

   312 		iFoundEquivalence=ETrue;

   313 		return KErrBadName;

   314 		}	

   315 

   316 	while (KErrNone==error)

   317 		{

   318 		//check for comments

   319 		while(data.Left(2)==(KCompsSipUriComment))

   320 			{

   321 			data.Zero();

   322 			iTUriParserFile.Read(data);

   323 			}

   324 		if (0==data.Compare(KCompsSipUriEquivalence))

   325 			{

   326 			iFoundEquivalence=ETrue;

   327 			break;

   328 			}

   329 		

   330 		//validate the 16 bit Sip URI first

   331 		iTestHarness->StartTestL(_L("Test TUriParser Component Validation (16-bit  SIP URI)"));

   332 		iTestHarness->LogIt(_L("Uri - %S"), &data);

   333 		error = DoSipUriValidation <TUriParser16>(data);

   334 		SipLogError(error, data);

   335 

   336 		// Make 8-bit copies and validate this SIP URI

   337 		HBufC8* uriBuf = HBufC8::NewLC(data.Length());

   338 		TPtr8 uri8Bit = uriBuf->Des();

   339 		uri8Bit.Copy(data);

   340 

   341 		iTestHarness->StartTestL(_L("Test TUriParser Component Validation (8-bit  SIP URI)"));	

   342 		iTestHarness->LogIt(_L("Uri - %S"), &data);

   343 		error = DoSipUriValidation <TUriParser8>(uri8Bit);

   344 		SipLogError(error, data);

   345 		

   346 		data.Zero();

   347 		CleanupStack::PopAndDestroy(1, uriBuf);// uriBuf

   348 		

   349 		error=iTUriParserFile.Read(data);

   350 		}

   351 	return KErrNone;		

   352 	}

   353 

   354 //

   355 //

   356 //	SIP Uri Equivalence Test

   357 //

   358 //

   359 TInt CSipUriAndAuthorityTest::SipUriEquivalenceL()

   360 	{

   361 	TBuf<256> valueA;

   362 	TBuf<256> valueB;

   363 	TBool sipUriError=EFalse;

   364 	TInt errorA=KErrNone;

   365 	TInt errorB=KErrNone;

   366 	TInt error=KErrNone;

   367 	

   368 	//get the Equivalence Data

   369 	errorA=iTUriParserFile.Read(valueA);

   370 	while(valueA.Left(2)==(KCompsSipUriComment) && KErrNone==errorA)

   371 		{

   372 		valueA.Zero();

   373 		errorA=iTUriParserFile.Read(valueA);

   374 		}

   375 	

   376 	errorB=iTUriParserFile.Read(valueB);	

   377 	//no Equivalence Data

   378 	if (KErrEof==errorA || KErrEof==errorB)

   379 		{

   380 		return KErrBadName;

   381 		}	

   382 	

   383 	//read the Equivalence Sip URI

   384 	while (KErrNone==errorA  && KErrNone==errorB)

   385 		{

   386 		//check for comments	

   387 		while(valueA.Left(2)==(KCompsSipUriComment))

   388 			{

   389 			valueA.Zero();

   390 			errorA=iTUriParserFile.Read(valueA);

   391 			}

   392 		while(valueB.Left(2)==(KCompsSipUriComment))

   393 			{

   394 			valueB.Zero();

   395 			errorB=iTUriParserFile.Read(valueB);

   396 			}

   397 		

   398 		//validate the 16 bit Sip URI first

   399 		iTestHarness->StartTestL(_L("Test TUriParser Component Equivalence (16-bit  SIP)"));	

   400 		iTestHarness->LogIt(_L("Uri - %S"), &valueA);

   401 		iTestHarness->LogIt(_L("Uri - %S"), &valueB);

   402 		

   403 		error= DoSipUriEquivalence<TUriParser16>(valueA, valueB, sipUriError);

   404 		//check for parsing errors on both Sip URIs

   405 		if (KErrBadSipUriA==sipUriError)

   406 			{

   407 			SipLogError(error, valueA);

   408 			}

   409 		if (KErrBadSipUriB==sipUriError)

   410 			{

   411 			SipLogError(error, valueB);

   412 			}

   413 		SipLogError(error, valueA);

   414 		

   415 		// Make 8-bit copies and validate this SIP URI

   416 		HBufC8* uriBufA = HBufC8::NewLC(valueA.Length());

   417 		TPtr8 uri8BitA = uriBufA->Des();

   418 		uri8BitA.Copy(valueA);

   419 

   420 		HBufC8* uriBufB = HBufC8::NewLC(valueB.Length());

   421 		TPtr8 uri8BitB = uriBufB->Des();

   422 		uri8BitB.Copy(valueB);

   423 

   424 		iTestHarness->StartTestL(_L("Test TUriParser Component Equivalence (8-bit  SIP)"));	

   425 		iTestHarness->LogIt(_L("Uri - %S"), &valueA);

   426 		iTestHarness->LogIt(_L("Uri - %S"), &valueB);

   427 		error = DoSipUriEquivalence<TUriParser8>(uri8BitA, uri8BitB, sipUriError);

   428 		//check for parsing errors on both Sip URIs

   429 		if (KErrBadSipUriA==sipUriError)

   430 			{

   431 			SipLogError(error, valueA);

   432 			}

   433 		if (KErrBadSipUriA==sipUriError)

   434 			{

   435 			SipLogError(error, valueB);

   436 			}

   437 		SipLogError(error, valueA);

   438 		

   439 		CleanupStack::PopAndDestroy(2, uriBufA);// uriBufA, uriBufB

   440 		

   441 		errorA=iTUriParserFile.Read(valueA);

   442 		errorB=iTUriParserFile.Read(valueB);

   443 		}

   444 	return KErrNone;

   445 	}

   446 

   447 //

   448 //

   449 //	SIP Uri Logger

   450 //

   451 //

   452 void CSipUriAndAuthorityTest::LogErrorMessage(const TDesC16& aSipUri, const TInt aError)const

   453 	{

   454 	switch (aError)

   455 		{

   456 		case KErrNotFound:

   457 			iTestHarness->LogIt(aSipUri);

   458 		        break;

   459 		        

   460 		case KErrNotSupported:

   461 			iTestHarness->LogIt(_L("Not Supported"));

   462 		        break;

   463 		        

   464 		case KUriUtilsErrInvalidScheme:

   465 		case KUriUtilsErrDifferentScheme:

   466 			iTestHarness->LogIt(_L("Invalid Scheme"));	

   467 		        break;

   468 		        

   469 		case KUriUtilsErrInvalidUserInfo:

   470 		case KUriUtilsErrDifferentUserInfo:

   471 			iTestHarness->LogIt(_L("Invalid UserInfo"));	

   472 		        break;

   473 		        

   474 		case KUriUtilsErrInvalidHost:

   475 		case KUriUtilsErrDifferentHost:

   476 			iTestHarness->LogIt(_L("Invalid Host"));	

   477 		        break;

   478 		        

   479 		case KUriUtilsErrInvalidPort:

   480 		case KUriUtilsErrDifferentPort:

   481 			iTestHarness->LogIt(_L("Invalid Port"));	

   482 		        break;

   483 		        

   484 		case KUriUtilsErrInvalidPath:

   485 		case KUriUtilsErrDifferentPath:

   486 			iTestHarness->LogIt(_L("Invalid Path"));	

   487 		        break;

   488 		        

   489 		case KUriUtilsErrInvalidParam:

   490 			iTestHarness->LogIt(_L("Invalid Parameter"));	

   491 		        break;

   492 		        

   493 		case KUriUtilsErrInvalidQuery:

   494 		case KUriUtilsErrDifferentQuery:

   495 			iTestHarness->LogIt(_L("Invalid Query"));	

   496 		        break;

   497 		        

   498 		case KUriUtilsErrInvalidHeaders:

   499 			iTestHarness->LogIt(_L("Invalid Headers"));	

   500 		        break;

   501 		        

   502 		case KUriUtilsErrInvalidFragment:

   503 		case KUriUtilsErrDifferentFragment:

   504 			iTestHarness->LogIt(_L("Invalid Fragment"));	

   505 			break;

   506 			

   507 		default:

   508 			break;

   509 		}

   510 		

   511 	//log correct message for equivalence

   512 	if (iFoundEquivalence && KErrNone==aError)

   513 		{

   514 		iTestHarness->LogIt(KCompsSipUriEqualMess0);

   515 		}

   516 	else if (iFoundEquivalence && KErrNone!=aError)

   517 		{

   518 		iTestHarness->LogIt(KCompsSipUriEqualMess1);

   519 		}

   520 	}

   521 

   522 //

   523 //

   524 //	Implementation of LOCAL functions

   525 //

   526 //

   527 

   528 template<class TUriParserType, class TDesCType>

   529 TInt DoSipUriValidation(const TDesCType& aSipUri)

   530 	{

   531 	TUriParserType uriParser;

   532 	TInt error = uriParser.Parse(aSipUri);

   533 	// Is this a valid SIP Uri?

   534 	if( KUriUtilsErrInvalidUri == error)

   535 		{

   536 		return error;

   537 		}

   538 

   539 	//Validate the Sip URI

   540 	return(uriParser.Validate());

   541 	}

   542 

   543 template<class TUriParserType, class TDesCType>

   544 TInt DoSipUriEquivalence(const TDesCType& aSipUriA, const TDesCType& aSipUriB,  TInt &aSipUriError)

   545 	{

   546 	TUriParserType uriParserA;

   547 	TUriParserType uriParserB;

   548 

   549 	TBool errorA = uriParserA.Parse(aSipUriA);

   550 	// Is this a valid SIP Uri?

   551 	if( KUriUtilsErrInvalidUri == errorA)

   552 		{

   553 		aSipUriError=KErrBadSipUriA;

   554 		return errorA;

   555 		}

   556 		

   557 	TBool errorB = uriParserB.Parse(aSipUriB);

   558 	// Is this a valid SIP Uri?

   559 	if( KUriUtilsErrInvalidUri == errorB)

   560 		{

   561 		aSipUriError=KErrBadSipUriB;

   562 		return errorB;

   563 		}

   564 	

   565 	return(uriParserA.Equivalent(uriParserB));

   566 	}

   567 

   568 //End of file
Symaptic