diff -r 000000000000 -r bde4ae8d615e os/ossrv/genericservices/httputils/Test/t_uriparser/t_UnitSipUri.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/ossrv/genericservices/httputils/Test/t_uriparser/t_UnitSipUri.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,361 @@
+// 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:
+// Unit tests for PREQ748 - Adding support for the SIP scheme in URIs.
+// Plus adding two new methods validate and equivalent
+// 
+//
+
+
+#include <e32base.h>
+#include <e32test.h>
+
+#include <uri8.h>
+#include <uri16.h>
+#include <uriutils.h>
+#include <uriutilscommon.h>
+#include "t_UnitSipUri.h"
+
+TBuf16<256> gFullUri16;
+TBuf16<256> gFullUriRhs16;
+TBuf16<256> gUriComponent16;
+
+_LIT(KTestName,"SIP Uri Unit Tests");
+LOCAL_D RTest test(KTestName);
+
+void ParseUriTests16BitL()
+	{	
+	test.Next(_L("Parsing 16 bit URIs"));
+	gFullUri16.Copy(KUri0);
+	CUri8* uri = UriUtils::CreateUriL(gFullUri16);
+	CleanupStack::PushL(uri);
+	
+	gUriComponent16.Copy(KScheme0);
+	HBufC* text = uri->Uri().DisplayFormL(EUriScheme);
+	TInt result = text->Compare(gUriComponent16) == 0? KErrNone : KUriUtilsErrDifferentScheme;
+	delete text;
+	User::LeaveIfError(result);
+
+	gUriComponent16.Copy(KUserInfo0);
+	text = uri->Uri().DisplayFormL(EUriUserinfo);
+	result = text->Compare(gUriComponent16) == 0? KErrNone : KUriUtilsErrDifferentUserInfo;
+	delete text;
+	User::LeaveIfError(result);
+	
+	gUriComponent16.Copy(KHost0);
+	text = uri->Uri().DisplayFormL(EUriHost);
+	result = text->Compare(gUriComponent16) == 0? KErrNone : KUriUtilsErrDifferentHost;
+	delete text;
+	User::LeaveIfError(result);
+	
+	gUriComponent16.Copy(KPort0);
+	text = uri->Uri().DisplayFormL(EUriPort);
+	result = text->Compare(gUriComponent16) == 0? KErrNone : KUriUtilsErrDifferentPort;
+	delete text;
+	User::LeaveIfError(result);
+
+	gUriComponent16.Copy(KParams0);
+	text = uri->Uri().DisplayFormL(EUriPath);
+	result = text->Compare(gUriComponent16) == 0? KErrNone : KUriUtilsErrDifferentPath;
+	delete text;
+	User::LeaveIfError(result);
+
+	gUriComponent16.Copy(KHeaders0);
+	text = uri->Uri().DisplayFormL(EUriQuery);
+	result = text->Compare(gUriComponent16) == 0? KErrNone : KUriUtilsErrDifferentQuery;
+	delete text;
+	User::LeaveIfError(result);
+	CleanupStack::PopAndDestroy(uri);
+	}
+	
+void ParseUriTestsDeprecated()
+	{	
+	test.Next(_L("Parsing 16 bit URIs (deprecated)"));
+	gFullUri16.Copy(KUri0);
+	TUriParser16 parser16;
+	parser16.Parse(gFullUri16);
+	gUriComponent16.Copy(KScheme0);
+	TInt result = parser16.Extract(EUriScheme).Compare(gUriComponent16);
+	test(!result);
+	gUriComponent16.Copy(KUserInfo0);
+	result = parser16.Extract(EUriUserinfo).Compare(gUriComponent16);
+	test(!result);
+	gUriComponent16.Copy(KHost0);
+	result = parser16.Extract(EUriHost).Compare(gUriComponent16);
+	test(!result);
+	gUriComponent16.Copy(KPort0);
+	result = parser16.Extract(EUriPort).Compare(gUriComponent16);
+	test(!result);
+	gUriComponent16.Copy(KParams0);
+	result = parser16.Extract(EUriPath).Compare(gUriComponent16);
+	test(!result);
+	gUriComponent16.Copy(KHeaders0);
+	result = parser16.Extract(EUriQuery).Compare(gUriComponent16);
+	test(!result);
+	}
+
+void ParseUriTests()
+	{
+	test.Next(_L("@SYMTestCaseID IWS-APPPROTOCOLS-INETURILIST-TESTUTILS-0001 Parsing 8 bit URIs"));
+	TUriParser8 parser8;
+	parser8.Parse(KUri0);
+	TInt result = parser8.Extract(EUriScheme).Compare(KScheme0);
+	test(!result);
+	result = parser8.Extract(EUriUserinfo).Compare(KUserInfo0);
+	test(!result);
+	result = parser8.Extract(EUriHost).Compare(KHost0);
+	test(!result);
+	result = parser8.Extract(EUriPort).Compare(KPort0);
+	test(!result);
+	result = parser8.Extract(EUriPath).Compare(KParams0);
+	test(!result);
+	result = parser8.Extract(EUriQuery).Compare(KHeaders0);
+	test(!result);
+	result =parser8.Parse(KParseUri);
+	test(!result);
+	ParseUriTestsDeprecated();
+	TRAP (result ,ParseUriTests16BitL());
+	test(result == KErrNone);
+	}
+
+void GenarateUriTestsL()
+	{
+	test.Next(_L("@SYMTestCaseID IWS-APPPROTOCOLS-INETURILIST-TESTUTILS-0002 Generating 8 bit URIs"));
+	CUri8* uri8 = CUri8::NewLC();
+	uri8->SetComponentL(KScheme0, EUriScheme);
+	uri8->SetComponentL(KHost0, EUriHost);
+	uri8->SetComponentL(KUserInfo0, EUriUserinfo);
+	uri8->SetComponentL(KPort0, EUriPort);
+	uri8->SetComponentL(KParams0, EUriPath);
+	uri8->SetComponentL(KHeaders0, EUriQuery);
+	const TDesC8& des8 = uri8->Uri().UriDes();
+	TInt result = des8.Compare(KUri0);
+	test(!result);
+	CleanupStack::PopAndDestroy(uri8);
+	
+	test.Next(_L("Generating 16 bit URIs"));
+	CUri16* uri16 = CUri16::NewLC();
+	gUriComponent16.Copy(KScheme0);
+	uri16->SetComponentL(gUriComponent16, EUriScheme);
+	gUriComponent16.Copy(KHost0);
+	uri16->SetComponentL(gUriComponent16, EUriHost);
+	gUriComponent16.Copy(KUserInfo0);
+	uri16->SetComponentL(gUriComponent16, EUriUserinfo);
+	gUriComponent16.Copy(KPort0);
+	uri16->SetComponentL(gUriComponent16, EUriPort);
+	gUriComponent16.Copy(KParams0);
+	uri16->SetComponentL(gUriComponent16, EUriPath);
+	gUriComponent16.Copy(KHeaders0);
+	uri16->SetComponentL(gUriComponent16, EUriQuery);
+	const TDesC16& des16 = uri16->Uri().UriDes();
+	gFullUri16.Copy(KUri0);
+	result = des16.Compare(gFullUri16);
+	test(!result);
+	CleanupStack::PopAndDestroy(uri16);
+	}
+
+void ValidateTest(const TDesC8& aUri, TInt aErrorToAssert)
+	{
+	TUriParser8 parser8;
+	TUriParser16 parser16;
+	parser8.Parse(aUri);
+	TInt result = parser8.Validate();
+	test(result == aErrorToAssert);
+	gFullUri16.Copy(aUri);
+	parser16.Parse(gFullUri16);
+	result = parser16.Validate();
+	test(result == aErrorToAssert);
+	}
+
+void ValidateSip8Test(const TDesC8& aUri, TInt aErrorToAssert)
+	{
+	TUriParser8 parser8;
+	parser8.Parse(aUri);
+	TInt result = parser8.Validate();
+	test(result == aErrorToAssert);
+	}
+	
+void ValidateUriTests()
+	{
+	test.Next(_L("@SYMTestCaseID IWS-APPPROTOCOLS-INETURILIST-TESTUTILS-0003 Validate URIs 8 and 16 bit"));
+	 
+	test.Next(_L("[Validate] Check full correct URI"));
+	ValidateTest(KVldUri0, KErrNone);
+	
+	test.Next(_L("[Validate] Check unsupported scheme"));
+	ValidateTest(KVldNotSupported, KErrNotSupported);
+	
+	test.Next(_L("[Validate] Check invalid hosts"));
+	ValidateTest(KVldInvalidHost0, KUriUtilsErrInvalidHost);
+	ValidateTest(KVldInvalidHost1, KUriUtilsErrInvalidHost);
+	ValidateTest(KVldInvalidHost2, KUriUtilsErrInvalidHost);
+	ValidateTest(KVldInvalidHost3, KUriUtilsErrInvalidHost);
+	ValidateTest(KVldInvalidHost4, KUriUtilsErrInvalidHost);
+	ValidateSip8Test(KVldInvalidHost5, KUriUtilsErrInvalidHost );
+	
+	test.Next(_L("[Validate] Check valid hosts"));
+	ValidateTest(KVldValidHost0, KErrNone);
+	ValidateTest(KVldValidHost1, KErrNone);
+	ValidateTest(KVldValidHost2, KErrNone);
+	
+	test.Next(_L("[Validate] Check invalid ports"));
+	ValidateTest(KVldInvalidPort0, KUriUtilsErrInvalidPort);
+	ValidateTest(KVldInvalidNoPort, KUriUtilsErrInvalidPort);
+	test.Next(_L("[Validate] Check valid ports"));
+	ValidateTest(KVldValidPort0, KErrNone);
+	
+	test.Next(_L("[Validate] Check invalid usernames and passwords"));
+	ValidateTest(KVldInvalidUserInfo0, KUriUtilsErrInvalidUserInfo);
+	ValidateTest(KVldInvalidUserInfo1, KUriUtilsErrInvalidUserInfo);
+	ValidateTest(KVldInvalidUserInfo2, KUriUtilsErrInvalidUserInfo);
+	ValidateTest(KVldInvalidUserInfo3, KUriUtilsErrInvalidUserInfo);
+	test.Next(_L("[Validate] Check valid usernames and passwords"));
+	ValidateTest(KVldValidUserInfo0, KErrNone);
+	ValidateTest(KVldValidUserInfo1, KErrNone);
+	ValidateTest(KVldValidUserInfo2, KErrNone);
+	ValidateTest(KVldValidUserInfo3, KErrNone);
+	
+	test.Next(_L("[Validate] Check invalid parameters"));
+	ValidateTest(KVldInvalidParams0, KUriUtilsErrInvalidParam);
+	ValidateTest(KVldInvalidParams1, KUriUtilsErrInvalidParam);
+	ValidateTest(KVldInvalidParams2, KUriUtilsErrInvalidParam);
+	ValidateTest(KVldInvalidParams3, KUriUtilsErrInvalidParam);
+	ValidateTest(KVldInvalidParams4, KUriUtilsErrInvalidParam);
+	ValidateTest(KVldInvalidParams5, KUriUtilsErrInvalidParam);
+	test.Next(_L("[Validate] Check valid parameters"));
+	ValidateTest(KVldValidParams0, KErrNone);
+	ValidateTest(KVldValidParams1, KErrNone);
+	ValidateTest(KVldValidParams2, KErrNone);
+	
+	test.Next(_L("[Validate] Check invalid headers"));
+	ValidateTest(KVldInvalidHeaders0, KUriUtilsErrInvalidHeaders);
+	ValidateTest(KVldInvalidHeaders1, KUriUtilsErrInvalidHeaders);
+	ValidateTest(KVldInvalidHeaders2, KUriUtilsErrInvalidHeaders);
+	test.Next(_L("[Validate] Check valid headers"));
+	ValidateTest(KVldValidHeaders0, KErrNone);
+	ValidateTest(KVldValidHeaders1, KErrNone);
+	ValidateTest(KVldValidHeaders2, KErrNone);
+	ValidateTest(KVldValidHeaders3, KErrNone);
+	
+	test.Next(_L("[Validate] General tests"));
+	ValidateTest(KVldInvalidGeneral1, KUriUtilsErrInvalidPort);
+	ValidateTest(KVldInvalidGeneral2, KUriUtilsErrInvalidHost);
+	ValidateTest(KVldValidGeneral1, KErrNone);
+	}
+	
+void EquivalenceTest(const TDesC8& aLhs, const TDesC8& aRhs, TInt aExpected)
+	{
+	TUriParser8 lhs8;
+	lhs8.Parse(aLhs);
+	TUriParser8 rhs8;
+	rhs8.Parse(aRhs);
+	TInt result = lhs8.Equivalent(rhs8);
+	test(result == aExpected);
+	
+	TUriParser16 lhs16;
+	gFullUri16.Copy(aLhs);
+	lhs16.Parse(gFullUri16);
+	TUriParser16 rhs16;
+	gFullUriRhs16.Copy(aRhs);
+	rhs16.Parse(gFullUriRhs16);
+	
+	result = lhs16.Equivalent(rhs16);
+	test(result == aExpected);
+	}
+	
+void EquivalenceUriTests()
+	{
+	test.Next(_L("@SYMTestCaseID IWS-APPPROTOCOLS-INETURILIST-TESTUTILS-0004 Equivalent URIs 8 and 16 bit"));
+	EquivalenceTest(KEquivUri0, KEquivUri0, KErrNone);
+	EquivalenceTest(KEquivUri0, KEquivScheme0, KErrNone);
+	
+	test.Next(_L("[Equivalent] Compare user names and passwords"));
+	EquivalenceTest(KEquivUri0, KEquivUserInfo0, KUriUtilsErrDifferentUserInfo);
+	EquivalenceTest(KEquivUri0, KEquivUserInfo1, KUriUtilsErrDifferentUserInfo);
+
+	test.Next(_L("[Equivalent] Compare hosts"));
+	EquivalenceTest(KEquivUri0, KEquivHost0, KErrNone);
+	EquivalenceTest(KEquivUri1, KEquivHost0, KUriUtilsErrDifferentHost);
+	EquivalenceTest(KEquivUri1, KEquivHost1, KErrNone);
+	
+	test.Next(_L("[Equivalent] Compare hosts"));
+	EquivalenceTest(KEquivUri0, KEquivPort0, KUriUtilsErrDifferentPort);
+	
+	test.Next(_L("[Equivalent] Compare parameters"));
+	EquivalenceTest(KEquivUri0, KEquivParam0, KErrNone);
+	EquivalenceTest(KEquivUri0, KEquivParam1, KErrNone);
+	EquivalenceTest(KEquivUri0, KEquivParam2, KUriUtilsErrDifferentPath);
+	EquivalenceTest(KEquivUri0, KEquivParam3, KUriUtilsErrDifferentPath);
+	EquivalenceTest(KEquivParam4, KEquivParam5, KErrNone);
+	EquivalenceTest(KEquivParam4, KEquivParam6, KErrNone);
+	EquivalenceTest(KEquivParam4, KEquivParam7, KUriUtilsErrDifferentPath);
+	EquivalenceTest(KEquivParam4, KEquivParam8, KUriUtilsErrDifferentPath);
+	EquivalenceTest(KEquivParam4, KEquivParam9, KUriUtilsErrDifferentPath);
+	EquivalenceTest(KEquivParam7, KEquivParam4, KUriUtilsErrDifferentPath);
+	EquivalenceTest(KEquivParam4, KEquivParam10, KErrNone);
+	EquivalenceTest(KEquivParam4, KEquivParam11, KUriUtilsErrDifferentPath);
+	EquivalenceTest(KEquivParam12, KEquivParam13, KUriUtilsErrDifferentPath);
+	EquivalenceTest(KEquivParam4, KEquivParam14, KUriUtilsErrDifferentPath);
+	EquivalenceTest(KEquivParam14, KEquivParam4, KUriUtilsErrDifferentPath);
+	
+	test.Next(_L("[Equivalent] Compare headers"));
+	EquivalenceTest(KEquivHeader0, KEquivHeader1, KErrNone);
+	EquivalenceTest(KEquivHeader0, KEquivHeader2, KUriUtilsErrDifferentQuery);
+	EquivalenceTest(KEquivHeader2, KEquivHeader0, KUriUtilsErrDifferentQuery);
+	EquivalenceTest(KEquivHeader2, KEquivHeader3, KErrNone);
+	EquivalenceTest(KEquivHeader3, KEquivHeader2, KErrNone);
+	EquivalenceTest(KEquivHeader4, KEquivHeader5, KErrNone);
+	EquivalenceTest(KEquivHeader4, KEquivHeader6, KErrNone);
+	EquivalenceTest(KEquivHeader4, KEquivHeader7, KUriUtilsErrDifferentQuery);
+	
+	test.Next(_L("[Equivalent] Expanded URIs"));
+	EquivalenceTest(KEquivUri0, KEquivExpand0, KErrNone);
+	EquivalenceTest(KEquivExpand0, KEquivUri0, KErrNone);
+	EquivalenceTest(KEquivUri0, KEquivExpand1, KErrNone);
+	EquivalenceTest(KEquivUri0, KEquivExpand2, KUriUtilsErrDifferentUserInfo);
+	EquivalenceTest(KEquivExpand3, KEquivExpand4, KErrNone);
+	EquivalenceTest(KEquivExpand4, KEquivExpand3, KErrNone);
+	
+	test.Next(_L("[Equivalent] General tests"));
+	EquivalenceTest(KEquivGeneral1, KEquivGeneral2, KUriUtilsErrDifferentPort);
+	}
+	
+void doMainL()
+	{
+	test.Start(_L("Starting unit tests"));
+	
+	ParseUriTests();
+	GenarateUriTestsL();
+	ValidateUriTests();
+	EquivalenceUriTests();
+	
+	test.End();
+	test.Close();
+	}
+
+GLDEF_C TInt E32Main()
+//
+// Main function
+	{
+	__UHEAP_MARK;
+
+	CTrapCleanup* theCleanup=CTrapCleanup::New();
+	TRAPD(ret,doMainL());
+	test(ret==KErrNone);
+	delete theCleanup;
+
+	__UHEAP_MARKEND;
+	
+	return KErrNone;
+	}
+