// 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>