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 // Unit tests for PREQ748 - Adding support for the SIP scheme in URIs.

    15 // Plus adding two new methods validate and equivalent

    16 // 

    17 //

    18 

    19 

    20 #include <e32base.h>

    21 #include <e32test.h>

    22 

    23 #include <uri8.h>

    24 #include <uri16.h>

    25 #include <uriutils.h>

    26 #include <uriutilscommon.h>

    27 #include "t_UnitSipUri.h"

    28 

    29 TBuf16<256> gFullUri16;

    30 TBuf16<256> gFullUriRhs16;

    31 TBuf16<256> gUriComponent16;

    32 

    33 _LIT(KTestName,"SIP Uri Unit Tests");

    34 LOCAL_D RTest test(KTestName);

    35 

    36 void ParseUriTests16BitL()

    37 	{	

    38 	test.Next(_L("Parsing 16 bit URIs"));

    39 	gFullUri16.Copy(KUri0);

    40 	CUri8* uri = UriUtils::CreateUriL(gFullUri16);

    41 	CleanupStack::PushL(uri);

    42 	

    43 	gUriComponent16.Copy(KScheme0);

    44 	HBufC* text = uri->Uri().DisplayFormL(EUriScheme);

    45 	TInt result = text->Compare(gUriComponent16) == 0? KErrNone : KUriUtilsErrDifferentScheme;

    46 	delete text;

    47 	User::LeaveIfError(result);

    48 

    49 	gUriComponent16.Copy(KUserInfo0);

    50 	text = uri->Uri().DisplayFormL(EUriUserinfo);

    51 	result = text->Compare(gUriComponent16) == 0? KErrNone : KUriUtilsErrDifferentUserInfo;

    52 	delete text;

    53 	User::LeaveIfError(result);

    54 	

    55 	gUriComponent16.Copy(KHost0);

    56 	text = uri->Uri().DisplayFormL(EUriHost);

    57 	result = text->Compare(gUriComponent16) == 0? KErrNone : KUriUtilsErrDifferentHost;

    58 	delete text;

    59 	User::LeaveIfError(result);

    60 	

    61 	gUriComponent16.Copy(KPort0);

    62 	text = uri->Uri().DisplayFormL(EUriPort);

    63 	result = text->Compare(gUriComponent16) == 0? KErrNone : KUriUtilsErrDifferentPort;

    64 	delete text;

    65 	User::LeaveIfError(result);

    66 

    67 	gUriComponent16.Copy(KParams0);

    68 	text = uri->Uri().DisplayFormL(EUriPath);

    69 	result = text->Compare(gUriComponent16) == 0? KErrNone : KUriUtilsErrDifferentPath;

    70 	delete text;

    71 	User::LeaveIfError(result);

    72 

    73 	gUriComponent16.Copy(KHeaders0);

    74 	text = uri->Uri().DisplayFormL(EUriQuery);

    75 	result = text->Compare(gUriComponent16) == 0? KErrNone : KUriUtilsErrDifferentQuery;

    76 	delete text;

    77 	User::LeaveIfError(result);

    78 	CleanupStack::PopAndDestroy(uri);

    79 	}

    80 	

    81 void ParseUriTestsDeprecated()

    82 	{	

    83 	test.Next(_L("Parsing 16 bit URIs (deprecated)"));

    84 	gFullUri16.Copy(KUri0);

    85 	TUriParser16 parser16;

    86 	parser16.Parse(gFullUri16);

    87 	gUriComponent16.Copy(KScheme0);

    88 	TInt result = parser16.Extract(EUriScheme).Compare(gUriComponent16);

    89 	test(!result);

    90 	gUriComponent16.Copy(KUserInfo0);

    91 	result = parser16.Extract(EUriUserinfo).Compare(gUriComponent16);

    92 	test(!result);

    93 	gUriComponent16.Copy(KHost0);

    94 	result = parser16.Extract(EUriHost).Compare(gUriComponent16);

    95 	test(!result);

    96 	gUriComponent16.Copy(KPort0);

    97 	result = parser16.Extract(EUriPort).Compare(gUriComponent16);

    98 	test(!result);

    99 	gUriComponent16.Copy(KParams0);

   100 	result = parser16.Extract(EUriPath).Compare(gUriComponent16);

   101 	test(!result);

   102 	gUriComponent16.Copy(KHeaders0);

   103 	result = parser16.Extract(EUriQuery).Compare(gUriComponent16);

   104 	test(!result);

   105 	}

   106 

   107 void ParseUriTests()

   108 	{

   109 	test.Next(_L("@SYMTestCaseID IWS-APPPROTOCOLS-INETURILIST-TESTUTILS-0001 Parsing 8 bit URIs"));

   110 	TUriParser8 parser8;

   111 	parser8.Parse(KUri0);

   112 	TInt result = parser8.Extract(EUriScheme).Compare(KScheme0);

   113 	test(!result);

   114 	result = parser8.Extract(EUriUserinfo).Compare(KUserInfo0);

   115 	test(!result);

   116 	result = parser8.Extract(EUriHost).Compare(KHost0);

   117 	test(!result);

   118 	result = parser8.Extract(EUriPort).Compare(KPort0);

   119 	test(!result);

   120 	result = parser8.Extract(EUriPath).Compare(KParams0);

   121 	test(!result);

   122 	result = parser8.Extract(EUriQuery).Compare(KHeaders0);

   123 	test(!result);

   124 	result =parser8.Parse(KParseUri);

   125 	test(!result);

   126 	ParseUriTestsDeprecated();

   127 	TRAP (result ,ParseUriTests16BitL());

   128 	test(result == KErrNone);

   129 	}

   130 

   131 void GenarateUriTestsL()

   132 	{

   133 	test.Next(_L("@SYMTestCaseID IWS-APPPROTOCOLS-INETURILIST-TESTUTILS-0002 Generating 8 bit URIs"));

   134 	CUri8* uri8 = CUri8::NewLC();

   135 	uri8->SetComponentL(KScheme0, EUriScheme);

   136 	uri8->SetComponentL(KHost0, EUriHost);

   137 	uri8->SetComponentL(KUserInfo0, EUriUserinfo);

   138 	uri8->SetComponentL(KPort0, EUriPort);

   139 	uri8->SetComponentL(KParams0, EUriPath);

   140 	uri8->SetComponentL(KHeaders0, EUriQuery);

   141 	const TDesC8& des8 = uri8->Uri().UriDes();

   142 	TInt result = des8.Compare(KUri0);

   143 	test(!result);

   144 	CleanupStack::PopAndDestroy(uri8);

   145 	

   146 	test.Next(_L("Generating 16 bit URIs"));

   147 	CUri16* uri16 = CUri16::NewLC();

   148 	gUriComponent16.Copy(KScheme0);

   149 	uri16->SetComponentL(gUriComponent16, EUriScheme);

   150 	gUriComponent16.Copy(KHost0);

   151 	uri16->SetComponentL(gUriComponent16, EUriHost);

   152 	gUriComponent16.Copy(KUserInfo0);

   153 	uri16->SetComponentL(gUriComponent16, EUriUserinfo);

   154 	gUriComponent16.Copy(KPort0);

   155 	uri16->SetComponentL(gUriComponent16, EUriPort);

   156 	gUriComponent16.Copy(KParams0);

   157 	uri16->SetComponentL(gUriComponent16, EUriPath);

   158 	gUriComponent16.Copy(KHeaders0);

   159 	uri16->SetComponentL(gUriComponent16, EUriQuery);

   160 	const TDesC16& des16 = uri16->Uri().UriDes();

   161 	gFullUri16.Copy(KUri0);

   162 	result = des16.Compare(gFullUri16);

   163 	test(!result);

   164 	CleanupStack::PopAndDestroy(uri16);

   165 	}

   166 

   167 void ValidateTest(const TDesC8& aUri, TInt aErrorToAssert)

   168 	{

   169 	TUriParser8 parser8;

   170 	TUriParser16 parser16;

   171 	parser8.Parse(aUri);

   172 	TInt result = parser8.Validate();

   173 	test(result == aErrorToAssert);

   174 	gFullUri16.Copy(aUri);

   175 	parser16.Parse(gFullUri16);

   176 	result = parser16.Validate();

   177 	test(result == aErrorToAssert);

   178 	}

   179 

   180 void ValidateSip8Test(const TDesC8& aUri, TInt aErrorToAssert)

   181 	{

   182 	TUriParser8 parser8;

   183 	parser8.Parse(aUri);

   184 	TInt result = parser8.Validate();

   185 	test(result == aErrorToAssert);

   186 	}

   187 	

   188 void ValidateUriTests()

   189 	{

   190 	test.Next(_L("@SYMTestCaseID IWS-APPPROTOCOLS-INETURILIST-TESTUTILS-0003 Validate URIs 8 and 16 bit"));

   191 	 

   192 	test.Next(_L("[Validate] Check full correct URI"));

   193 	ValidateTest(KVldUri0, KErrNone);

   194 	

   195 	test.Next(_L("[Validate] Check unsupported scheme"));

   196 	ValidateTest(KVldNotSupported, KErrNotSupported);

   197 	

   198 	test.Next(_L("[Validate] Check invalid hosts"));

   199 	ValidateTest(KVldInvalidHost0, KUriUtilsErrInvalidHost);

   200 	ValidateTest(KVldInvalidHost1, KUriUtilsErrInvalidHost);

   201 	ValidateTest(KVldInvalidHost2, KUriUtilsErrInvalidHost);

   202 	ValidateTest(KVldInvalidHost3, KUriUtilsErrInvalidHost);

   203 	ValidateTest(KVldInvalidHost4, KUriUtilsErrInvalidHost);

   204 	ValidateSip8Test(KVldInvalidHost5, KUriUtilsErrInvalidHost );

   205 	

   206 	test.Next(_L("[Validate] Check valid hosts"));

   207 	ValidateTest(KVldValidHost0, KErrNone);

   208 	ValidateTest(KVldValidHost1, KErrNone);

   209 	ValidateTest(KVldValidHost2, KErrNone);

   210 	

   211 	test.Next(_L("[Validate] Check invalid ports"));

   212 	ValidateTest(KVldInvalidPort0, KUriUtilsErrInvalidPort);

   213 	ValidateTest(KVldInvalidNoPort, KUriUtilsErrInvalidPort);

   214 	test.Next(_L("[Validate] Check valid ports"));

   215 	ValidateTest(KVldValidPort0, KErrNone);

   216 	

   217 	test.Next(_L("[Validate] Check invalid usernames and passwords"));

   218 	ValidateTest(KVldInvalidUserInfo0, KUriUtilsErrInvalidUserInfo);

   219 	ValidateTest(KVldInvalidUserInfo1, KUriUtilsErrInvalidUserInfo);

   220 	ValidateTest(KVldInvalidUserInfo2, KUriUtilsErrInvalidUserInfo);

   221 	ValidateTest(KVldInvalidUserInfo3, KUriUtilsErrInvalidUserInfo);

   222 	test.Next(_L("[Validate] Check valid usernames and passwords"));

   223 	ValidateTest(KVldValidUserInfo0, KErrNone);

   224 	ValidateTest(KVldValidUserInfo1, KErrNone);

   225 	ValidateTest(KVldValidUserInfo2, KErrNone);

   226 	ValidateTest(KVldValidUserInfo3, KErrNone);

   227 	

   228 	test.Next(_L("[Validate] Check invalid parameters"));

   229 	ValidateTest(KVldInvalidParams0, KUriUtilsErrInvalidParam);

   230 	ValidateTest(KVldInvalidParams1, KUriUtilsErrInvalidParam);

   231 	ValidateTest(KVldInvalidParams2, KUriUtilsErrInvalidParam);

   232 	ValidateTest(KVldInvalidParams3, KUriUtilsErrInvalidParam);

   233 	ValidateTest(KVldInvalidParams4, KUriUtilsErrInvalidParam);

   234 	ValidateTest(KVldInvalidParams5, KUriUtilsErrInvalidParam);

   235 	test.Next(_L("[Validate] Check valid parameters"));

   236 	ValidateTest(KVldValidParams0, KErrNone);

   237 	ValidateTest(KVldValidParams1, KErrNone);

   238 	ValidateTest(KVldValidParams2, KErrNone);

   239 	

   240 	test.Next(_L("[Validate] Check invalid headers"));

   241 	ValidateTest(KVldInvalidHeaders0, KUriUtilsErrInvalidHeaders);

   242 	ValidateTest(KVldInvalidHeaders1, KUriUtilsErrInvalidHeaders);

   243 	ValidateTest(KVldInvalidHeaders2, KUriUtilsErrInvalidHeaders);

   244 	test.Next(_L("[Validate] Check valid headers"));

   245 	ValidateTest(KVldValidHeaders0, KErrNone);

   246 	ValidateTest(KVldValidHeaders1, KErrNone);

   247 	ValidateTest(KVldValidHeaders2, KErrNone);

   248 	ValidateTest(KVldValidHeaders3, KErrNone);

   249 	

   250 	test.Next(_L("[Validate] General tests"));

   251 	ValidateTest(KVldInvalidGeneral1, KUriUtilsErrInvalidPort);

   252 	ValidateTest(KVldInvalidGeneral2, KUriUtilsErrInvalidHost);

   253 	ValidateTest(KVldValidGeneral1, KErrNone);

   254 	}

   255 	

   256 void EquivalenceTest(const TDesC8& aLhs, const TDesC8& aRhs, TInt aExpected)

   257 	{

   258 	TUriParser8 lhs8;

   259 	lhs8.Parse(aLhs);

   260 	TUriParser8 rhs8;

   261 	rhs8.Parse(aRhs);

   262 	TInt result = lhs8.Equivalent(rhs8);

   263 	test(result == aExpected);

   264 	

   265 	TUriParser16 lhs16;

   266 	gFullUri16.Copy(aLhs);

   267 	lhs16.Parse(gFullUri16);

   268 	TUriParser16 rhs16;

   269 	gFullUriRhs16.Copy(aRhs);

   270 	rhs16.Parse(gFullUriRhs16);

   271 	

   272 	result = lhs16.Equivalent(rhs16);

   273 	test(result == aExpected);

   274 	}

   275 	

   276 void EquivalenceUriTests()

   277 	{

   278 	test.Next(_L("@SYMTestCaseID IWS-APPPROTOCOLS-INETURILIST-TESTUTILS-0004 Equivalent URIs 8 and 16 bit"));

   279 	EquivalenceTest(KEquivUri0, KEquivUri0, KErrNone);

   280 	EquivalenceTest(KEquivUri0, KEquivScheme0, KErrNone);

   281 	

   282 	test.Next(_L("[Equivalent] Compare user names and passwords"));

   283 	EquivalenceTest(KEquivUri0, KEquivUserInfo0, KUriUtilsErrDifferentUserInfo);

   284 	EquivalenceTest(KEquivUri0, KEquivUserInfo1, KUriUtilsErrDifferentUserInfo);

   285 

   286 	test.Next(_L("[Equivalent] Compare hosts"));

   287 	EquivalenceTest(KEquivUri0, KEquivHost0, KErrNone);

   288 	EquivalenceTest(KEquivUri1, KEquivHost0, KUriUtilsErrDifferentHost);

   289 	EquivalenceTest(KEquivUri1, KEquivHost1, KErrNone);

   290 	

   291 	test.Next(_L("[Equivalent] Compare hosts"));

   292 	EquivalenceTest(KEquivUri0, KEquivPort0, KUriUtilsErrDifferentPort);

   293 	

   294 	test.Next(_L("[Equivalent] Compare parameters"));

   295 	EquivalenceTest(KEquivUri0, KEquivParam0, KErrNone);

   296 	EquivalenceTest(KEquivUri0, KEquivParam1, KErrNone);

   297 	EquivalenceTest(KEquivUri0, KEquivParam2, KUriUtilsErrDifferentPath);

   298 	EquivalenceTest(KEquivUri0, KEquivParam3, KUriUtilsErrDifferentPath);

   299 	EquivalenceTest(KEquivParam4, KEquivParam5, KErrNone);

   300 	EquivalenceTest(KEquivParam4, KEquivParam6, KErrNone);

   301 	EquivalenceTest(KEquivParam4, KEquivParam7, KUriUtilsErrDifferentPath);

   302 	EquivalenceTest(KEquivParam4, KEquivParam8, KUriUtilsErrDifferentPath);

   303 	EquivalenceTest(KEquivParam4, KEquivParam9, KUriUtilsErrDifferentPath);

   304 	EquivalenceTest(KEquivParam7, KEquivParam4, KUriUtilsErrDifferentPath);

   305 	EquivalenceTest(KEquivParam4, KEquivParam10, KErrNone);

   306 	EquivalenceTest(KEquivParam4, KEquivParam11, KUriUtilsErrDifferentPath);

   307 	EquivalenceTest(KEquivParam12, KEquivParam13, KUriUtilsErrDifferentPath);

   308 	EquivalenceTest(KEquivParam4, KEquivParam14, KUriUtilsErrDifferentPath);

   309 	EquivalenceTest(KEquivParam14, KEquivParam4, KUriUtilsErrDifferentPath);

   310 	

   311 	test.Next(_L("[Equivalent] Compare headers"));

   312 	EquivalenceTest(KEquivHeader0, KEquivHeader1, KErrNone);

   313 	EquivalenceTest(KEquivHeader0, KEquivHeader2, KUriUtilsErrDifferentQuery);

   314 	EquivalenceTest(KEquivHeader2, KEquivHeader0, KUriUtilsErrDifferentQuery);

   315 	EquivalenceTest(KEquivHeader2, KEquivHeader3, KErrNone);

   316 	EquivalenceTest(KEquivHeader3, KEquivHeader2, KErrNone);

   317 	EquivalenceTest(KEquivHeader4, KEquivHeader5, KErrNone);

   318 	EquivalenceTest(KEquivHeader4, KEquivHeader6, KErrNone);

   319 	EquivalenceTest(KEquivHeader4, KEquivHeader7, KUriUtilsErrDifferentQuery);

   320 	

   321 	test.Next(_L("[Equivalent] Expanded URIs"));

   322 	EquivalenceTest(KEquivUri0, KEquivExpand0, KErrNone);

   323 	EquivalenceTest(KEquivExpand0, KEquivUri0, KErrNone);

   324 	EquivalenceTest(KEquivUri0, KEquivExpand1, KErrNone);

   325 	EquivalenceTest(KEquivUri0, KEquivExpand2, KUriUtilsErrDifferentUserInfo);

   326 	EquivalenceTest(KEquivExpand3, KEquivExpand4, KErrNone);

   327 	EquivalenceTest(KEquivExpand4, KEquivExpand3, KErrNone);

   328 	

   329 	test.Next(_L("[Equivalent] General tests"));

   330 	EquivalenceTest(KEquivGeneral1, KEquivGeneral2, KUriUtilsErrDifferentPort);

   331 	}

   332 	

   333 void doMainL()

   334 	{

   335 	test.Start(_L("Starting unit tests"));

   336 	

   337 	ParseUriTests();

   338 	GenarateUriTestsL();

   339 	ValidateUriTests();

   340 	EquivalenceUriTests();

   341 	

   342 	test.End();

   343 	test.Close();

   344 	}

   345 

   346 GLDEF_C TInt E32Main()

   347 //

   348 // Main function

   349 	{

   350 	__UHEAP_MARK;

   351 

   352 	CTrapCleanup* theCleanup=CTrapCleanup::New();

   353 	TRAPD(ret,doMainL());

   354 	test(ret==KErrNone);

   355 	delete theCleanup;

   356 

   357 	__UHEAP_MARKEND;

   358 	

   359 	return KErrNone;

   360 	}

   361