--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/genericservices/httputils/Test/t_uriparser/CSipUriAndAuthorityTest.cpp	Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,568 @@
+// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include "CSipUriAndAuthorityTest.h"
+#include "CUriAndAuthorityTest.h"
+#include <uriutilscommon.h>
+#include "SipUriAndAuthorityTests.h"
+
+#include <e32base.h>
+#include <f32file.h>
+
+CSipUriAndAuthorityTest* CSipUriAndAuthorityTest::NewLC(CIpuTestHarness* aTestHarness)
+	{
+	CSipUriAndAuthorityTest* self = new (ELeave) CSipUriAndAuthorityTest(aTestHarness);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+CSipUriAndAuthorityTest* CSipUriAndAuthorityTest::NewL(CIpuTestHarness* aTestHarness)
+	{
+	CSipUriAndAuthorityTest* self = CSipUriAndAuthorityTest::NewLC(aTestHarness);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CSipUriAndAuthorityTest::CSipUriAndAuthorityTest(CIpuTestHarness* aTestHarness)
+: iTestHarness(aTestHarness)
+	{
+	}
+
+void CSipUriAndAuthorityTest::ConstructL()
+	{
+	}
+
+CSipUriAndAuthorityTest::~CSipUriAndAuthorityTest()
+	{
+	}
+
+//
+//
+//	SIP Uri tests
+//
+//
+void CSipUriAndAuthorityTest::DoTestsL()
+	{
+	//allredy pushed
+	CUriAndAuthorityTest* uriAndAuthorityTest = CUriAndAuthorityTest::NewLC(iTestHarness);
+
+	// Test Sips TUriParser Component Extraction
+	uriAndAuthorityTest->TestUriComponentExtractionL(KCompsSip0, KSchemeSip0, KUserInfoSip0, KHostSip0, KPortSip0, KPathSip0, KQuerySip0, KFragmentSip0);
+	uriAndAuthorityTest->TestUriComponentExtractionL(KCompsSip1, KSchemeSip1, KUserInfoSip1, KHostSip1, KPortSip1, KPathSip1, KQuerySip1, KFragmentSip1);
+	uriAndAuthorityTest->TestUriComponentExtractionL(KCompsSip2, KSchemeSip2, KUserInfoSip2, KHostSip2, KPortSip2, KPathSip2, KQuerySip2, KFragmentSip2);
+	uriAndAuthorityTest->TestUriComponentExtractionL(KCompsSip3, KSchemeSip3, KUserInfoSip3, KHostSip3, KPortSip3, KPathSip3, KQuerySip3, KFragmentSip3);
+	uriAndAuthorityTest->TestUriComponentExtractionL(KCompsSip4, KSchemeSip4, KUserInfoSip4, KHostSip4, KPortSip4, KPathSip4, KQuerySip4, KFragmentSip4);
+	uriAndAuthorityTest->TestUriComponentExtractionL(KCompsSip5, KSchemeSip5, KUserInfoSip5, KHostSip5, KPortSip5, KPathSip5, KQuerySip5, KFragmentSip5);		
+	
+	// Sip URI construction test
+	uriAndAuthorityTest->TestUriSetComponentL(KSipUri_Scheme0, KSipUri_Host0, KSipUri_Userinfo0, KSipUri_Port0, KSipUri_Path0, KSipUri_Query0, KSipUri_Fragment0,
+		KSipUri_SchemeComp0, KSipUri_HostComp0, KSipUri_UserinfoComp0, KSipUri_PortComp0, KSipUri_PathComp0, KSipUri_QueryComp0, KSipUri_FragmentComp0);
+	
+/** No Fragment part exist in Sip Uri's as per RFC3261
+	// Sip URI destruction test
+	uriAndAuthorityTest->TestUriRemoveComponentL(KSipUri_NoScheme0, KSipUri_NoHost0, KSipUri_NoUserinfo0, KSipUri_NoPort0, KSipUri_NoPath0,
+		KSipUri_NoQuery0, KSipUri_NoFragment0, KSipUri_Whole0);
+*/
+	// Same test as above, but with an IPv6 format host
+	// Sip URI construction test
+	uriAndAuthorityTest->TestUriSetComponentL(KSipUri_Scheme0, KSipUri_IPv6Host0, KSipUri_IPv6UserInfo0, KSipUri_IPv6Port0, KSipUri_IPv6Path0, KSipUri_IPv6Query0, KSipUri_IPv6Fragment0,
+		KSipUri_SchemeComp0, KUri_IPv6HostComp, KSipUri_UserinfoComp0, KSipUri_PortComp0, KSipUri_PathComp0, KSipUri_QueryComp0, KSipUri_FragmentComp0);
+
+/** No Fragment part exist in Sip Uri's as per RFC3261
+	// Sip URI destruction test
+	uriAndAuthorityTest->TestUriRemoveComponentL(KSipUri_IPv6NoScheme0, KSipUri_IPv6NoHost0, KSipUri_IPv6NoUserinfo0, KSipUri_IPv6NoPort0, KSipUri_IPv6NoPath0,
+		KSipUri_IPv6NoQuery0, KSipUri_IPv6NoFragment0, KSipUri_IPv6Whole0);
+*/	
+	CleanupStack::PopAndDestroy(uriAndAuthorityTest);
+	
+	//Sip URI validation
+	TInt error=KErrNone;
+	error=OpenSipURIFile();
+	if (KErrNone!=error)
+		{
+		iTestHarness->StartTestL(_L("Test TUriParser Component "));
+		SipLogError(error, KCompsSipUriFileSystemError);
+		}
+	else
+		{
+		error=SipUriValidationL();		
+	   	if (KErrNone!=error)
+			{
+			iTestHarness->StartTestL(_L("Test TUriParser Component Validation "));
+			switch (error)
+				{
+			case KErrNotFound:
+				{
+				iTestHarness->LogIt(KCompsSipUriNoValidate);	
+				}
+				break;
+			case KErrBadName:
+				{
+				iTestHarness->LogIt(KCompsSipUriNoValidateData);
+				}
+				break;
+			default:
+				break;
+				}
+			iTestHarness->EndTest(KErrNone);	
+			}	
+		
+		if (iFoundEquivalence)
+			{
+			error=SipUriEquivalenceL();
+			//No Sip URI Equivalence data
+			if (KErrBadName==error)
+				{
+				iTestHarness->StartTestL(_L("Test TUriParser Component Equivalence "));
+				iTestHarness->LogIt(KCompsSipUriNoEquivalenceData);
+				iTestHarness->EndTest(KErrNone);
+				}
+			}
+		else
+			{
+			iTestHarness->StartTestL(_L("Test TUriParser Component Equivalence "));
+			iTestHarness->LogIt(KCompsSipUriNoEquivalence);
+			iTestHarness->EndTest(KErrNone);
+			error=KErrNone;
+			}
+		iFsSession.Close();
+		}
+	}
+	
+//
+//
+//	Open SIP Uri data file
+//
+//
+TInt CSipUriAndAuthorityTest::OpenSipURIFile()
+	{
+	RFile file;
+	TInt error=KErrNone;
+
+	error = iFsSession.Connect();
+	if (KErrNone!=error)
+		{
+		return error;			
+		}
+		
+	error = file.Open(iFsSession, KCompsSipUriFileName, EFileRead);
+	if (KErrNone!=error)
+		{
+		iFsSession.Close();
+		return error;			
+		}
+
+	iTUriParserFile.Set(file);
+	return error;
+	}
+	
+//
+//
+//	SIP Uri Logger
+//
+//
+void CSipUriAndAuthorityTest::SipLogError(TInt aError, const TDesC16& aSipUri) const
+	{
+	TBool wrongError=EFalse;
+	
+	//compare the Equivalent SIP URI to look for the correct error, these SIP URIs must be in T_UriParserSipUri.txt
+	//All equal
+	if (0==aSipUri.Compare(KCompsSipUriEqual0) && KErrNone != aError 
+		|| 0==aSipUri.Compare(KCompsSipUriEqual1) && KErrNone != aError 
+		|| 0==aSipUri.Compare(KCompsSipUriEqual2) && KErrNone != aError)
+		{
+		iTestHarness->LogIt(KCompsSipUriValidMess0);
+		wrongError=ETrue;
+		}
+	//All not equal		
+	if (0==aSipUri.Compare(KCompsSipUriNotEqual0) && KUriUtilsErrDifferentUserInfo == aError 
+		|| 0==aSipUri.Compare(KCompsSipUriNotEqual1) && KUriUtilsErrDifferentPath  == aError 
+		|| 0==aSipUri.Compare(KCompsSipUriNotEqual2) && KUriUtilsErrDifferentPort  == aError )
+		{
+		iTestHarness->LogIt(KCompsSipUriEqualMess1);
+		}
+
+	//compare the SIP URIs to look for the correct error returned by CUri for validation
+	if (0==aSipUri.Compare(KCompsSipUriNotEqual1) && KUriUtilsErrDifferentPath  != aError )
+		{
+		iTestHarness->LogIt(KCompsSipUriInvalidMess9);
+		wrongError=ETrue;
+		}
+
+
+	if (0==aSipUri.Compare(KCompsSipUriValid0) && KErrNone!= aError
+		|| 0==aSipUri.Compare(KCompsSipUriValid1) && KErrNone!= aError)
+		{
+		iTestHarness->LogIt(KCompsSipUriValidMess0);
+		wrongError=ETrue;
+		}
+
+	if (0==aSipUri.Compare(KCompsSipUriInvalid0) && KErrNotSupported != aError)
+		{
+		iTestHarness->LogIt(KCompsSipUriInvalidMess0);
+		wrongError=ETrue;
+		}
+	
+	if( 0==aSipUri.Compare(KCompsSipUriInvalid5) && KUriUtilsErrInvalidParam!= aError
+		|| 0==aSipUri.Compare(KCompsSipUriInvalid6) && KUriUtilsErrInvalidParam!= aError)
+		{
+		iTestHarness->LogIt(KCompsSipUriInvalidMess1);
+		wrongError=ETrue;
+		}
+	
+	if (0==aSipUri.Compare(KCompsSipUriInvalid3) && KUriUtilsErrInvalidHost!= aError)
+		{
+		iTestHarness->LogIt(KCompsSipUriInvalidMess2);
+		wrongError=ETrue;
+		}
+		
+	if (0==aSipUri.Compare(KCompsSipUriInvalid2) && KUriUtilsErrInvalidHeaders != aError)
+		{
+		iTestHarness->LogIt(KCompsSipUriInvalidMess8);
+		wrongError=ETrue;
+		}
+
+	if (0==aSipUri.Compare(KCompsSipUriInvalid1) && KUriUtilsErrInvalidPort != aError
+		|| 0==aSipUri.Compare(KCompsSipUriInvalid4) && KUriUtilsErrInvalidPort!= aError
+		|| 0==aSipUri.Compare(KCompsSipUriNotEqual2) && KUriUtilsErrDifferentPort  != aError)
+		{
+		iTestHarness->LogIt(KCompsSipUriInvalidMess3);
+		wrongError=ETrue;
+		}
+
+	if (0==aSipUri.Compare(KCompsSipUriInvalid7) && KUriUtilsErrInvalidUserInfo!= aError
+		|| 0==aSipUri.Compare(KCompsSipUriNotEqual0) && KUriUtilsErrDifferentUserInfo != aError)
+		{
+		iTestHarness->LogIt(KCompsSipUriInvalidMess7);
+		wrongError=ETrue;
+		}
+
+	if (wrongError)
+		{
+		iTestHarness->LogIt(KCompsSipUriInvalidMess5);
+		}
+	
+	LogErrorMessage(aSipUri, aError);
+	
+	if (wrongError)
+		{
+		iTestHarness->EndTest(aError);
+		}		
+	else
+		{
+		iTestHarness->EndTest(KErrNone);	
+		}
+	}
+
+//
+//
+//	SIP Uri Validation Test
+//
+//
+TInt CSipUriAndAuthorityTest::SipUriValidationL()
+	{
+	TBuf<256> data;
+	TInt error=KErrNone;
+	iFoundEquivalence=EFalse;
+	
+	//read the Valid section name in
+	error=iTUriParserFile.Read(data);
+	while(0!=data.Compare(KCompsSipUriValidate) && KErrNone==error)
+		{
+		if (0==data.Compare(KCompsSipUriEquivalence))
+			{
+			iFoundEquivalence=ETrue;
+			break;
+			}
+		data.Zero();
+		error=iTUriParserFile.Read(data);
+		}
+		
+	//No Validate Section, KErrEof
+	if (0!=data.Compare(KCompsSipUriValidate))
+		{
+		return KErrNotFound;
+		}
+	
+	//get the validation Data
+	error=iTUriParserFile.Read(data);
+	
+	//no data
+	if (KErrEof==error)
+		{
+		return KErrBadName;
+		}	
+	
+	//found Equivalence
+	if (0==data.Compare(KCompsSipUriEquivalence))
+		{
+		iFoundEquivalence=ETrue;
+		return KErrBadName;
+		}	
+
+	while (KErrNone==error)
+		{
+		//check for comments
+		while(data.Left(2)==(KCompsSipUriComment))
+			{
+			data.Zero();
+			iTUriParserFile.Read(data);
+			}
+		if (0==data.Compare(KCompsSipUriEquivalence))
+			{
+			iFoundEquivalence=ETrue;
+			break;
+			}
+		
+		//validate the 16 bit Sip URI first
+		iTestHarness->StartTestL(_L("Test TUriParser Component Validation (16-bit  SIP URI)"));
+		iTestHarness->LogIt(_L("Uri - %S"), &data);
+		error = DoSipUriValidation <TUriParser16>(data);
+		SipLogError(error, data);
+
+		// Make 8-bit copies and validate this SIP URI
+		HBufC8* uriBuf = HBufC8::NewLC(data.Length());
+		TPtr8 uri8Bit = uriBuf->Des();
+		uri8Bit.Copy(data);
+
+		iTestHarness->StartTestL(_L("Test TUriParser Component Validation (8-bit  SIP URI)"));	
+		iTestHarness->LogIt(_L("Uri - %S"), &data);
+		error = DoSipUriValidation <TUriParser8>(uri8Bit);
+		SipLogError(error, data);
+		
+		data.Zero();
+		CleanupStack::PopAndDestroy(1, uriBuf);// uriBuf
+		
+		error=iTUriParserFile.Read(data);
+		}
+	return KErrNone;		
+	}
+
+//
+//
+//	SIP Uri Equivalence Test
+//
+//
+TInt CSipUriAndAuthorityTest::SipUriEquivalenceL()
+	{
+	TBuf<256> valueA;
+	TBuf<256> valueB;
+	TBool sipUriError=EFalse;
+	TInt errorA=KErrNone;
+	TInt errorB=KErrNone;
+	TInt error=KErrNone;
+	
+	//get the Equivalence Data
+	errorA=iTUriParserFile.Read(valueA);
+	while(valueA.Left(2)==(KCompsSipUriComment) && KErrNone==errorA)
+		{
+		valueA.Zero();
+		errorA=iTUriParserFile.Read(valueA);
+		}
+	
+	errorB=iTUriParserFile.Read(valueB);	
+	//no Equivalence Data
+	if (KErrEof==errorA || KErrEof==errorB)
+		{
+		return KErrBadName;
+		}	
+	
+	//read the Equivalence Sip URI
+	while (KErrNone==errorA  && KErrNone==errorB)
+		{
+		//check for comments	
+		while(valueA.Left(2)==(KCompsSipUriComment))
+			{
+			valueA.Zero();
+			errorA=iTUriParserFile.Read(valueA);
+			}
+		while(valueB.Left(2)==(KCompsSipUriComment))
+			{
+			valueB.Zero();
+			errorB=iTUriParserFile.Read(valueB);
+			}
+		
+		//validate the 16 bit Sip URI first
+		iTestHarness->StartTestL(_L("Test TUriParser Component Equivalence (16-bit  SIP)"));	
+		iTestHarness->LogIt(_L("Uri - %S"), &valueA);
+		iTestHarness->LogIt(_L("Uri - %S"), &valueB);
+		
+		error= DoSipUriEquivalence<TUriParser16>(valueA, valueB, sipUriError);
+		//check for parsing errors on both Sip URIs
+		if (KErrBadSipUriA==sipUriError)
+			{
+			SipLogError(error, valueA);
+			}
+		if (KErrBadSipUriB==sipUriError)
+			{
+			SipLogError(error, valueB);
+			}
+		SipLogError(error, valueA);
+		
+		// Make 8-bit copies and validate this SIP URI
+		HBufC8* uriBufA = HBufC8::NewLC(valueA.Length());
+		TPtr8 uri8BitA = uriBufA->Des();
+		uri8BitA.Copy(valueA);
+
+		HBufC8* uriBufB = HBufC8::NewLC(valueB.Length());
+		TPtr8 uri8BitB = uriBufB->Des();
+		uri8BitB.Copy(valueB);
+
+		iTestHarness->StartTestL(_L("Test TUriParser Component Equivalence (8-bit  SIP)"));	
+		iTestHarness->LogIt(_L("Uri - %S"), &valueA);
+		iTestHarness->LogIt(_L("Uri - %S"), &valueB);
+		error = DoSipUriEquivalence<TUriParser8>(uri8BitA, uri8BitB, sipUriError);
+		//check for parsing errors on both Sip URIs
+		if (KErrBadSipUriA==sipUriError)
+			{
+			SipLogError(error, valueA);
+			}
+		if (KErrBadSipUriA==sipUriError)
+			{
+			SipLogError(error, valueB);
+			}
+		SipLogError(error, valueA);
+		
+		CleanupStack::PopAndDestroy(2, uriBufA);// uriBufA, uriBufB
+		
+		errorA=iTUriParserFile.Read(valueA);
+		errorB=iTUriParserFile.Read(valueB);
+		}
+	return KErrNone;
+	}
+
+//
+//
+//	SIP Uri Logger
+//
+//
+void CSipUriAndAuthorityTest::LogErrorMessage(const TDesC16& aSipUri, const TInt aError)const
+	{
+	switch (aError)
+		{
+		case KErrNotFound:
+			iTestHarness->LogIt(aSipUri);
+		        break;
+		        
+		case KErrNotSupported:
+			iTestHarness->LogIt(_L("Not Supported"));
+		        break;
+		        
+		case KUriUtilsErrInvalidScheme:
+		case KUriUtilsErrDifferentScheme:
+			iTestHarness->LogIt(_L("Invalid Scheme"));	
+		        break;
+		        
+		case KUriUtilsErrInvalidUserInfo:
+		case KUriUtilsErrDifferentUserInfo:
+			iTestHarness->LogIt(_L("Invalid UserInfo"));	
+		        break;
+		        
+		case KUriUtilsErrInvalidHost:
+		case KUriUtilsErrDifferentHost:
+			iTestHarness->LogIt(_L("Invalid Host"));	
+		        break;
+		        
+		case KUriUtilsErrInvalidPort:
+		case KUriUtilsErrDifferentPort:
+			iTestHarness->LogIt(_L("Invalid Port"));	
+		        break;
+		        
+		case KUriUtilsErrInvalidPath:
+		case KUriUtilsErrDifferentPath:
+			iTestHarness->LogIt(_L("Invalid Path"));	
+		        break;
+		        
+		case KUriUtilsErrInvalidParam:
+			iTestHarness->LogIt(_L("Invalid Parameter"));	
+		        break;
+		        
+		case KUriUtilsErrInvalidQuery:
+		case KUriUtilsErrDifferentQuery:
+			iTestHarness->LogIt(_L("Invalid Query"));	
+		        break;
+		        
+		case KUriUtilsErrInvalidHeaders:
+			iTestHarness->LogIt(_L("Invalid Headers"));	
+		        break;
+		        
+		case KUriUtilsErrInvalidFragment:
+		case KUriUtilsErrDifferentFragment:
+			iTestHarness->LogIt(_L("Invalid Fragment"));	
+			break;
+			
+		default:
+			break;
+		}
+		
+	//log correct message for equivalence
+	if (iFoundEquivalence && KErrNone==aError)
+		{
+		iTestHarness->LogIt(KCompsSipUriEqualMess0);
+		}
+	else if (iFoundEquivalence && KErrNone!=aError)
+		{
+		iTestHarness->LogIt(KCompsSipUriEqualMess1);
+		}
+	}
+
+//
+//
+//	Implementation of LOCAL functions
+//
+//
+
+template<class TUriParserType, class TDesCType>
+TInt DoSipUriValidation(const TDesCType& aSipUri)
+	{
+	TUriParserType uriParser;
+	TInt error = uriParser.Parse(aSipUri);
+	// Is this a valid SIP Uri?
+	if( KUriUtilsErrInvalidUri == error)
+		{
+		return error;
+		}
+
+	//Validate the Sip URI
+	return(uriParser.Validate());
+	}
+
+template<class TUriParserType, class TDesCType>
+TInt DoSipUriEquivalence(const TDesCType& aSipUriA, const TDesCType& aSipUriB,  TInt &aSipUriError)
+	{
+	TUriParserType uriParserA;
+	TUriParserType uriParserB;
+
+	TBool errorA = uriParserA.Parse(aSipUriA);
+	// Is this a valid SIP Uri?
+	if( KUriUtilsErrInvalidUri == errorA)
+		{
+		aSipUriError=KErrBadSipUriA;
+		return errorA;
+		}
+		
+	TBool errorB = uriParserB.Parse(aSipUriB);
+	// Is this a valid SIP Uri?
+	if( KUriUtilsErrInvalidUri == errorB)
+		{
+		aSipUriError=KErrBadSipUriB;
+		return errorB;
+		}
+	
+	return(uriParserA.Equivalent(uriParserB));
+	}
+
+//End of file