1 // Copyright (c) 2001-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 // Implementation of CHttpHdrCodecTest

    15 // 

    16 //

    17 

    18 #include <inetprottextutils.h>

    19 #include "t_hdrcodec.h"

    20 

    21 _LIT8(KFieldSeparator, "\n");

    22 

    23 

    24 void CHttpHdrCodecTest::DoRunL()

    25 	{

    26 	iExpectedStatusCode = 0;

    27 	// insert test code here, allow it to leave if the test fails

    28 	RunTestsL();

    29 	}

    30 	

    31 TInt CHttpHdrCodecTest::RunError(TInt aErr)

    32 	{

    33 	iEngine->Utils().LogIt(_L("\nTest failed with error code %d\n"), aErr);

    34 	return KErrNone;

    35 	}

    36 

    37 void CHttpHdrCodecTest::DoCancel()

    38 	{

    39 	}

    40 	

    41 const TDesC& CHttpHdrCodecTest::TestName()

    42 	{

    43 	_LIT(KHeaderTestName,"CHttpHdrCodecTest");

    44 	return KHeaderTestName;

    45 	}

    46 

    47 CHttpHdrCodecTest::CHttpHdrCodecTest()

    48 // Constructor

    49 	{

    50 	// Initial timestamp is time now

    51 	ResetTimeElapsed();

    52 	}

    53 

    54 CHttpHdrCodecTest::~CHttpHdrCodecTest()

    55 // Destructor (virtual)

    56 	{

    57 	}

    58 

    59 CHttpHdrCodecTest* CHttpHdrCodecTest::NewLC()

    60 // Create a new CHttpHdrCodecTest and place it on the clean-up stack then return it

    61 	{

    62 	CHttpHdrCodecTest* me = new(ELeave) CHttpHdrCodecTest;

    63 	CleanupStack::PushL(me);

    64 	return me;

    65 	}

    66 

    67 CHttpHdrCodecTest* CHttpHdrCodecTest::NewL()

    68 // Create a new CHttpHdrCodecTest and return it

    69 	{

    70 	CHttpHdrCodecTest* me = new(ELeave) CHttpHdrCodecTest;

    71 	return me;

    72 	}

    73 

    74 void CHttpHdrCodecTest::RunTestsL()

    75 	{

    76 	// start the session

    77 	iSession.OpenL();

    78 	CleanupClosePushL(iSession);

    79 	// Locate the string pool

    80 	iStrP = iSession.StringPool();

    81 

    82 	_LIT8(KTxtHTTPProt, "HTTP/TCP");

    83 	iProtHnd = CProtocolHandler::NewL(KTxtHTTPProt(), iSession);

    84 	CleanupStack::PushL(iProtHnd);

    85 

    86 	iEngine->Console().Printf(_L("\nStart of header codec tests"));

    87 	ResetTimeElapsed();

    88 

    89 	// Run tests on parsed -> OTA data conversions, for each header implemented

    90 	TestEncodeAcceptL();

    91 	TestEncodeAcceptCharsetL();

    92 	TestEncodeAuthorizationL();

    93 	TestEncodeConnectionL();

    94 	TestEncodeContentLengthL();

    95 	TestEncodeContentTypeL();

    96 	TestEncodeHostL();

    97 	TestEncodeTransferEncodingL();

    98 	TestEncodeUserAgentL();

    99 	TestEncodeDateL();

   100 	TestEncodeLocaleIndependentDateL();

   101 	TestEncodeUpgradeL();

   102 

   103 	TestEncodeCookieL();

   104 	TestEncodeCacheControlL();

   105 

   106 	// Run tests on OTA data -> parsed conversions, for each header implemented

   107 	TestDecodeConnectionL();

   108 	TestDecodeContentLengthL();

   109 	TestDecodeContentTypeL();

   110 	TestDecodeContentTypeWithMultipleParametersL();

   111 	TestDecodeContentTypeMissingParameterL();

   112 	TestDecodeServerL();

   113 	TestDecodeDateL();

   114 	TestDecodeTransferEncodingL();

   115 	TestDecodeWWWAuthenticateL();

   116 	TestDecodeUpgradeL();

   117 

   118 	TestDecodeSetCookieL();

   119 	TestDecodeSetCookie2L();

   120 	TestDecodeSetCookie3L();

   121 	TestDecodeSetCookie4L();

   122 	//test for DEF080697: Cookies: When sending a request to an origin server, Browser is not sending the

   123 	TestEncodeCookiePortL();

   124 

   125 

   126 	TestDecodeCacheControlL();

   127 

   128 	// Do some round trip encode->decode and check the original input is the same as the final output

   129 	TestRoundTripConnectionL();

   130 	TestRoundTripContentLengthL();

   131 	TestRoundTripContentLength2L();

   132 	TestRoundTripContentTypeL();

   133 	TestRoundTripTransferEncodingL();

   134 	

   135 	TestDuplicateHeaderResponsesL();

   136 	

   137 	//test for DEF078684: Authorization header nonce count is sent incorrectly

   138 	TestEncodeAuthorization1L();

   139 

   140 	//test for INC118854:Invalid parsing of HTTP headers when value contains a ";" character 

   141 	TestDecodeContentDispositionL();

   142 

   143 	TestGetCustomFieldValueL();

   144 	

   145 	TestGetCustomFieldNullValueL();

   146 

   147 	TestGetCustomFieldNoValueL();

   148 	

   149 	// test for PDEF138861: Trying to access header field part at Index < 0

   150 	TestInvalidHeaderFieldPartL ();

   151 	

   152 	// End of tests

   153 	DisplayTimeElapsed();

   154 	iEngine->Console().Printf(_L("\nEnd of header codec tests"));

   155 	CleanupStack::PopAndDestroy(2,&iSession);

   156 	}

   157 

   158 void CHttpHdrCodecTest::TestDuplicateHeaderResponsesL()

   159 	{

   160 	// Test Headers that are handled by textmode codec

   161 	

   162 	// Response with 2 connection type headers

   163 	TInt numParts=2; 

   164 	RStringF header = iStrP.StringF(HTTP::EConnection, RHTTPSession::GetTable());

   165 	_LIT8(KConnectionRawHeader1, "close\nkeep-alive");

   166 	TestDuplicateHeaderDecodingL(header,KConnectionRawHeader1, numParts);

   167 	

   168 	_LIT8(KConnectionRawHeader2, "close, keep-alive");

   169 	TestDuplicateHeaderDecodingL(header,KConnectionRawHeader2, numParts);

   170 	

   171 	// Response with 2 content type headers

   172 	numParts=1;

   173 	header = iStrP.StringF(HTTP::EContentType, RHTTPSession::GetTable());

   174 	_LIT8(KContentTypeRawHeader1, "text/html\ntext/html");

   175 	TestDuplicateHeaderDecodingL(header, KContentTypeRawHeader1,numParts);

   176 					

   177 	// Response with 2 different date headers 

   178 	// This also checks Expires and Last-Modified as they use the same generic date parsing in

   179 	// the codec

   180 	header = iStrP.StringF(HTTP::EDate, RHTTPSession::GetTable());

   181 	_LIT8(KDateRawHeader1, "Tue, 15 Nov 1994 08:12:31 GMT\n Wed, 16 Nov 1994 09:00:30 GMT");

   182 	TestDuplicateHeaderDecodingL(header, KDateRawHeader1, numParts);					

   183 

   184     // Response with 3 different content length headers

   185 	// This also checks Age as that uses the same generic number parsing

   186 	header = iStrP.StringF(HTTP::EContentLength, RHTTPSession::GetTable());

   187 	_LIT8(KContentLengthRawHeader1, "10\n200\n3000");

   188 	TestDuplicateHeaderDecodingL(header, KContentLengthRawHeader1, numParts);					

   189 

   190     

   191     // Response with 2 different transfer-encodings

   192     numParts=2;

   193     header = iStrP.StringF(HTTP::ETransferEncoding, RHTTPSession::GetTable());

   194     _LIT8(KTransferEncodingRawHeader1, "chunked\nchunked2");

   195     TestDuplicateHeaderDecodingL(header, KTransferEncodingRawHeader1, numParts);

   196     

   197     // Response with 2 different WWWAuthenticate headers

   198     header = iStrP.StringF(HTTP::EWWWAuthenticate, RHTTPSession::GetTable());

   199     _LIT8(KWWWAuthenticateRawHeader1, "basic realm=castle\nbasic realm=magic");

   200     TestDuplicateHeaderDecodingL(header, KWWWAuthenticateRawHeader1, numParts);

   201 	

   202 	// Response with 2 different SetCookie headers

   203 	// Also tests SetCookie2 as that goes through same codec

   204 	header = iStrP.StringF(HTTP::ESetCookie, RHTTPSession::GetTable());

   205     _LIT8(KSetCookieRawHeader1, "cookie=chocolate\ncookie=ginger");

   206     TestDuplicateHeaderDecodingL(header, KSetCookieRawHeader1, numParts);

   207 	

   208     // Response with 2 cache control headers

   209     header = iStrP.StringF(HTTP::ECacheControl, RHTTPSession::GetTable());

   210     _LIT8(KCacheControlRawHeader1, "max-age=100\nno-transform");

   211     TestDuplicateHeaderDecodingL(header, KCacheControlRawHeader1, numParts);

   212     

   213     

   214     header = iStrP.StringF(HTTP::ECacheControl, RHTTPSession::GetTable());

   215     _LIT8(KCacheControlRawHeader2, "max-age=100, no-transform");

   216     TestDuplicateHeaderDecodingL(header, KCacheControlRawHeader2, numParts);

   217 	

   218     

   219 	// Response with 2 pragma headers

   220 	// This also tests vary and content-langugage which both use same generic parser

   221 	header = iStrP.StringF(HTTP::EPragma, RHTTPSession::GetTable());

   222     _LIT8(KPragmaRawHeader1, "pragma1\npragma2");

   223     TestDuplicateHeaderDecodingL(header, KPragmaRawHeader1, numParts);

   224     

   225     

   226     // Test some headers that will use the default codec

   227     numParts=2;

   228     // Response with 2 ETag headers

   229     header = iStrP.StringF(HTTP::EETag, RHTTPSession::GetTable());

   230     _LIT8(KETagRawHeader1, "\"xxxyz\"\n\"xyyz\"");

   231     TestDuplicateHeaderDecodingL(header, KETagRawHeader1, numParts);

   232 	

   233 	header = iStrP.StringF(HTTP::EETag, RHTTPSession::GetTable());

   234     _LIT8(KETagRawHeader2, "\"xxxyz\"\n\"xyyz\"   ");

   235     TestDuplicateHeaderDecodingL(header, KETagRawHeader2, numParts);

   236 	

   237 	

   238 	

   239 	// Default codec with one header

   240 	numParts=1;

   241     header = iStrP.StringF(HTTP::EETag, RHTTPSession::GetTable());

   242     _LIT8(KETagRawHeader3, "\"xxxyz\"");

   243     TestDuplicateHeaderDecodingL(header, KETagRawHeader3, numParts);

   244     

   245 	iEngine->Utils().LogIt ( _L ("\nTestDuplicateHeaderResponsesL test success."));

   246 	}

   247 

   248 

   249 void CHttpHdrCodecTest::TestDuplicateHeaderDecodingL(RStringF aHeader,

   250 												 const TDesC8& aRawResponseHeader,

   251 												 TInt aExpectedNumberParts)

   252 	/* This is to test decoding of multiple response headers

   253 	   HTTP Framework deals with these by joining them together using \n as a seperator

   254 	*/

   255 	{

   256 	RHTTPHeaders headers = GetHeadersLC();

   257 	headers.SetRawFieldL(aHeader, aRawResponseHeader, KFieldSeparator);

   258 	

   259 	// Check parsing of raw header. Framework should only return first header if there are duplicates

   260 	// Don't bother checking multiple values on one line.

   261 	TPtrC8 rawHeader(KNullDesC8);

   262 	User::LeaveIfError(headers.GetRawField(aHeader,rawHeader));

   263 	TInt firstNewLinePosition = aRawResponseHeader.Locate('\n');

   264 	if (firstNewLinePosition != KErrNotFound)

   265 		{

   266 		TPtrC8 expectedRawResponse(rawHeader.Left(firstNewLinePosition));

   267 		if (rawHeader.CompareF(expectedRawResponse) != 0)

   268 			{

   269 			TBuf < 1024 > rawHeader16;

   270 			TBuf < 1024 > expectedRawResponse16;

   271 			rawHeader16.Copy ( rawHeader );

   272 			expectedRawResponse16.Copy ( expectedRawResponse );

   273 			

   274 			iEngine->Utils().LogIt ( _L("Raw header comparison failed -> %S != %S"), &rawHeader16, &expectedRawResponse16 );

   275 			User::Leave(KErrArgument);

   276 			}

   277 		}

   278 

   279 	

   280 	// Check parsing when converting through codec

   281 	TInt numberParts = headers.FieldPartsL(aHeader);

   282 	if (numberParts != aExpectedNumberParts)

   283 		{

   284 		iEngine->Utils().LogIt ( _L("\nNumber parts differ from expected. -> %d != %d"), numberParts, aExpectedNumberParts );

   285 		User::Leave(KErrArgument);

   286 		}

   287 	

   288 	

   289 	ReleaseHeaders();

   290 	

   291 	iEngine->Utils().LogIt ( _L ("\nTestDuplicateHeaderDecodingL test success."));

   292 	}

   293 

   294 

   295 void CHttpHdrCodecTest::TestEncodeAcceptL()

   296 	{

   297 	// the result we expect and that we will validate

   298 	_LIT8(KAcceptOTAVal, "text/html; q=0.8, text/vnd.wap.wml; q=0.2; extended=value, text/*");

   299 

   300 	// Open strings used in this test

   301 	RStringF textHtml = iStrP.StringF(HTTP::ETextHtml,RHTTPSession::GetTable());

   302 	RStringF textWml  = iStrP.StringF(HTTP::ETextVndWapWml,RHTTPSession::GetTable());

   303 	RStringF textAny  = iStrP.StringF(HTTP::ETextAny,RHTTPSession::GetTable());

   304 

   305 	RStringF extended  = iStrP.OpenFStringL(_L8("extended"));

   306 	CleanupClosePushL(extended);

   307 	RStringF extendVal = iStrP.OpenFStringL(_L8("value"));

   308 	CleanupClosePushL(extendVal);

   309 	//

   310 	iEngine->Console().Printf(_L("\nTest encoding 'Accept' header"));

   311 	

   312 	RHTTPHeaders hdr = 	GetHeadersLC();

   313 

   314 	// Set up the parsed header

   315 	RStringF accept = iStrP.StringF(HTTP::EAccept,RHTTPSession::GetTable());

   316 	THTTPHdrVal accVal(textHtml);

   317 	THTTPHdrVal q(THTTPHdrVal::TQConv(0.8));

   318 	hdr.SetFieldL(accept, accVal, iStrP.StringF(HTTP::EQ,RHTTPSession::GetTable()), q);

   319 	accVal.SetStrF(textWml);

   320 	q.SetInt(THTTPHdrVal::TQConv(0.2));

   321 	hdr.SetFieldL(accept, accVal, iStrP.StringF(HTTP::EQ,RHTTPSession::GetTable()), q);

   322 	q.SetStrF(extendVal);

   323 	hdr.SetFieldL(accept, accVal, extended, q);

   324 	accVal.SetStrF(textAny);

   325 	hdr.SetFieldL(accept, accVal);

   326 

   327 	// now get the OTA data

   328 	TPtrC8 ota;

   329 	hdr.GetRawField(accept, ota);

   330 	if (ota.Compare(KAcceptOTAVal()) != 0)

   331 		{		

   332 		TBuf<512> ota16;

   333 		ota16.Copy (ota);		

   334 		iEngine->Utils().LogIt ( _L("\nAccept OTA comparison failed -> %S"), &ota16 );

   335 		User::Leave(KErrArgument);		

   336 		}

   337 		

   338 

   339 	// Close strings used in this test

   340 	ReleaseHeaders();

   341 	CleanupStack::PopAndDestroy(2, &extended);

   342 	

   343 	iEngine->Utils().LogIt ( _L ("\nTestEncodeAcceptL test success."));

   344 	}

   345 

   346 void CHttpHdrCodecTest::TestEncodeAcceptCharsetL()

   347 	{

   348 	// the result we expect and that we will validate

   349 	_LIT8(KAccChSetOTAVal, "iso-8859-5, unicode-1-1; q=0.8");

   350 

   351 	// Open strings used in this test

   352 	RStringF iso8859_5 = iStrP.OpenFStringL(_L8("iso-8859-5"));

   353 	CleanupClosePushL(iso8859_5);

   354 	RStringF unicode1_1  = iStrP.OpenFStringL(_L8("unicode-1-1"));

   355 	CleanupClosePushL(unicode1_1);

   356 

   357 	iEngine->Console().Printf(_L("\nTest encoding 'Accept-Charset' header"));

   358 	RHTTPHeaders hdr = GetHeadersLC();

   359 	

   360 	// Set up the parsed header

   361 	RStringF accChSet= iStrP.StringF(HTTP::EAcceptCharset,RHTTPSession::GetTable());

   362 	THTTPHdrVal accChSetVal(iso8859_5);

   363 	hdr.SetFieldL(accChSet, accChSetVal);

   364 	//

   365 	accChSetVal.SetStrF(unicode1_1);

   366 	THTTPHdrVal q(THTTPHdrVal::TQConv(0.8));

   367 	hdr.SetFieldL(accChSet, accChSetVal, iStrP.StringF(HTTP::EQ,RHTTPSession::GetTable()), q);

   368 

   369 	// now get the OTA data

   370 	TPtrC8 ota;

   371 	hdr.GetRawField(accChSet, ota);

   372 	if (ota.Compare(KAccChSetOTAVal()) != 0)

   373 		{

   374 		TBuf<512> ota16;

   375 		ota16.Copy (ota);		

   376 		iEngine->Utils().LogIt ( _L("\nComparison of charset field failed -> %S"), &ota16 );	

   377 		User::Leave(KErrArgument);

   378 		}

   379 		

   380 

   381 	ReleaseHeaders();

   382 

   383 	CleanupStack::PopAndDestroy(2, &iso8859_5);

   384 	iEngine->Utils().LogIt ( _L ("\nTestEncodeAcceptCharsetL test success."));

   385 	}

   386 

   387 //test for DEF078684: Authorization header nonce count is sent incorrectly

   388 void CHttpHdrCodecTest::TestEncodeAuthorization1L()

   389 {

   390 	// the result we expect and that we will validate

   391 	_LIT8(KAuthorizationOTAVal, "Digest nc=00000001, algorithm=MD5, nonce=\"999999\"");

   392 	

   393 	// Open strings used in this test

   394 	RString ncVal = iStrP.OpenStringL(_L8("00000001"));

   395 	CleanupClosePushL(ncVal);

   396 

   397 	RString algVal = iStrP.OpenStringL(_L8("MD5"));

   398 	CleanupClosePushL(algVal);

   399 

   400 	RString nonceVal = iStrP.OpenStringL(_L8("999999"));

   401 	CleanupClosePushL(nonceVal);

   402 	

   403 	//

   404 	iEngine->Console().Printf(_L("\nTest encoding 'Authorization' header"));

   405 	RHTTPHeaders hdr = GetHeadersLC();

   406 

   407 	RStringF authStr = iStrP.StringF(HTTP::EAuthorization,RHTTPSession::GetTable());

   408 	THTTPHdrVal authVal(iStrP.StringF(HTTP::EDigest,RHTTPSession::GetTable()));

   409 	THTTPHdrVal hdrNcVal(ncVal);

   410 

   411 	RStringF ncStr = iStrP.StringF(HTTP::ENc,RHTTPSession::GetTable());

   412 	hdr.SetFieldL(authStr, authVal,ncStr,hdrNcVal);

   413 

   414 	THTTPHdrVal hdralgVal(algVal);

   415 	RStringF algStr = iStrP.StringF(HTTP::EAlgorithm,RHTTPSession::GetTable());

   416 	hdr.SetFieldL(authStr, authVal,algStr,hdralgVal);

   417 

   418 	THTTPHdrVal hdrnonceVal(nonceVal);

   419 	RStringF nonceStr = iStrP.StringF(HTTP::ENonce,RHTTPSession::GetTable());

   420 	hdr.SetFieldL(authStr, authVal,nonceStr,hdrnonceVal);

   421 	

   422 	// now get the OTA data

   423 	TPtrC8 ota;

   424 	hdr.GetRawField(authStr, ota);

   425 	if (ota.Compare(KAuthorizationOTAVal()) != 0)

   426 		{

   427 		TBuf<512> ota16;

   428 		ota16.Copy (ota);

   429 		iEngine->Utils().LogIt ( _L("\nComparison of Authorization field failed -> %S"), &ota16 );	

   430 		User::Leave(KErrArgument);

   431 		}

   432 

   433 	ReleaseHeaders();

   434 	

   435 	CleanupStack::PopAndDestroy(&nonceVal);

   436 	CleanupStack::PopAndDestroy(&algVal);

   437 	CleanupStack::PopAndDestroy(&ncVal);

   438 	iEngine->Utils().LogIt ( _L ("\nTestEncodeAuthorizationL test success."));

   439 }

   440 void CHttpHdrCodecTest::TestEncodeAuthorizationL()

   441 	{

   442 	// the result we expect and that we will validate

   443 	_LIT8(KAuthorizationOTAVal, "Basic c3ltYmlhbjpmMXN5bmNtbA==");

   444 

   445 	// Open strings used in this test

   446 	RString basicCred = iStrP.OpenStringL(_L8("c3ltYmlhbjpmMXN5bmNtbA=="));

   447 	CleanupClosePushL(basicCred);

   448 	//

   449 	iEngine->Console().Printf(_L("\nTest encoding 'Authorization' header"));

   450 	RHTTPHeaders hdr = GetHeadersLC();

   451 

   452 	RStringF authStr = iStrP.StringF(HTTP::EAuthorization,RHTTPSession::GetTable());

   453 	THTTPHdrVal authVal(iStrP.StringF(HTTP::EBasic,RHTTPSession::GetTable()));

   454 	hdr.SetFieldL(authStr, authVal); // sets part 1

   455 	THTTPHdrVal credVal(basicCred);

   456 	hdr.SetFieldL(authStr, credVal); // sets part 2

   457 

   458 	// now get the OTA data

   459 	TPtrC8 ota;

   460 	hdr.GetRawField(authStr, ota);

   461 	if (ota.Compare(KAuthorizationOTAVal()) != 0)

   462 		{

   463 		TBuf<512> ota16;

   464 		ota16.Copy (ota);

   465 		iEngine->Utils().LogIt ( _L("\nComparison of Authorization field failed -> %S"), &ota16 );	

   466 		User::Leave(KErrArgument);

   467 		}

   468 		

   469 

   470 	ReleaseHeaders();

   471 	

   472 	CleanupStack::PopAndDestroy(&basicCred);

   473 	iEngine->Utils().LogIt ( _L ("\nTestEncodeAuthorizationL test success."));

   474 	}

   475 

   476 void CHttpHdrCodecTest::TestEncodeConnectionL()

   477 	{

   478 	// the result we expect and that we will validate

   479 	_LIT8(KConnectionOTAVal, "close, keep-alive");

   480 

   481 	// Open strings used in this test

   482 	RStringF otherToken = iStrP.StringF(HTTP::EKeepAlive,RHTTPSession::GetTable());

   483 	//

   484 	iEngine->Console().Printf(_L("\nTest encoding 'Connection' header"));

   485 	RHTTPHeaders hdr = GetHeadersLC();

   486 	RStringF connStr = iStrP.StringF(HTTP::EConnection,RHTTPSession::GetTable());

   487 	THTTPHdrVal connVal(iStrP.StringF(HTTP::EClose,RHTTPSession::GetTable()));

   488 	hdr.SetFieldL(connStr, connVal); // sets part 1

   489 	THTTPHdrVal keepAlive(otherToken);

   490 	hdr.SetFieldL(connStr, keepAlive); // sets part 2

   491 

   492 	// now get the OTA data

   493 	TPtrC8 ota;

   494 	hdr.GetRawField(connStr, ota);

   495 	if (ota.CompareF(KConnectionOTAVal()) != 0)

   496 		{

   497 		TBuf<512> ota16;

   498 		ota16.Copy (ota);

   499 		iEngine->Utils().LogIt ( _L("\nComparison of connection field failed -> %S"), &ota16 );	

   500 		User::Leave(KErrArgument);

   501 		}

   502 		

   503 	ReleaseHeaders();

   504 	

   505 	iEngine->Utils().LogIt ( _L ("\nTestEncodeConnectionL test success.\n"));

   506 	}

   507 

   508 void CHttpHdrCodecTest::TestEncodeContentLengthL()

   509 	{

   510 	// the result we expect and that we will validate

   511 	_LIT8(KContentLengthOTAVal, "12345");

   512 	//

   513 	iEngine->Console().Printf(_L("\nTest encoding 'Content-Length' header"));

   514 	RHTTPHeaders hdr = GetHeadersLC();

   515 	RStringF lengthStr = iStrP.StringF(HTTP::EContentLength,RHTTPSession::GetTable());

   516 	THTTPHdrVal lengthVal(12345);

   517 	hdr.SetFieldL(lengthStr, lengthVal); // sets part 1

   518 

   519 	// now get the OTA data

   520 	TPtrC8 ota;

   521 	hdr.GetRawField(lengthStr, ota);

   522 	if (ota.Compare(KContentLengthOTAVal()) != 0)

   523 		{

   524 		TBuf<512> ota16;

   525 		ota16.Copy (ota);

   526 		iEngine->Utils().LogIt ( _L("\nComparison of content length field value failed. -> %S"), &ota16 );	

   527 		User::Leave(KErrArgument);

   528 		}

   529 		

   530 	ReleaseHeaders();

   531 	iEngine->Utils().LogIt ( _L ("\nTestEncodeContentLengthL test success."));

   532 	}

   533 

   534 void CHttpHdrCodecTest::TestEncodeContentTypeL()

   535 	{

   536 	// the result we expect and that we will validate

   537 	_LIT8(KContentTypeOTAVal1, "text/plain");

   538 	_LIT8(KContentTypeOTAVal2, "text/html; charset=us-ascii");

   539 	_LIT8(KContentTypeOTAVal3, "text/vnd.wap.wml; charset=utf-8; transcode=yes");

   540 

   541 	// Open strings used in this test

   542 	RStringF textHtml  = iStrP.StringF(HTTP::ETextHtml,RHTTPSession::GetTable());

   543 	RStringF textWml   = iStrP.StringF(HTTP::ETextVndWapWml,RHTTPSession::GetTable());

   544 	RStringF textPlain = iStrP.StringF(HTTP::ETextPlain,RHTTPSession::GetTable());

   545 

   546 	RStringF usAscii   = iStrP.OpenFStringL(_L8("us-ascii"));

   547 	CleanupClosePushL(usAscii);

   548 	RStringF utf8	  = iStrP.OpenFStringL(_L8("utf-8"));

   549 	CleanupClosePushL(utf8);

   550 	RStringF extended  = iStrP.OpenFStringL(_L8("transcode"));

   551 	CleanupClosePushL(extended);

   552 	RStringF extendVal = iStrP.OpenFStringL(_L8("yes"));

   553 	CleanupClosePushL(extendVal);

   554 	//

   555 	iEngine->Console().Printf(_L("\nTest encoding 'Content-Type' header (no params)"));

   556 	RHTTPHeaders hdr = GetHeadersLC();

   557 

   558 	// Set up the parsed header

   559 	RStringF contType = iStrP.StringF(HTTP::EContentType,RHTTPSession::GetTable());

   560 	THTTPHdrVal ctVal(textPlain);

   561 	hdr.SetFieldL(contType, ctVal);

   562 

   563 	// now get the OTA data

   564 	TPtrC8 ota;

   565 	hdr.GetRawField(contType, ota);

   566 	if (ota.Compare(KContentTypeOTAVal1()) != 0)

   567 		{

   568 		TBuf<512> ota16;

   569 		ota16.Copy (ota);

   570 		iEngine->Utils().LogIt ( _L("\nComparison of content type (no params) field failed. -> %S"), &ota16);	

   571 		User::Leave(KErrArgument);

   572 		}

   573 		

   574 	//

   575 	iEngine->Console().Printf(_L("\nTest encoding 'Content-Type' header (with charset parameter)"));

   576 	hdr.RemoveField(contType);

   577 	ctVal.SetStrF(textHtml);

   578 	THTTPHdrVal chSet(usAscii);

   579 	hdr.SetFieldL(contType, ctVal, iStrP.StringF(HTTP::ECharset,RHTTPSession::GetTable()), chSet);

   580 	hdr.GetRawField(contType, ota);

   581 	if (ota.Compare(KContentTypeOTAVal2()) != 0)

   582 		{

   583 		TBuf<512> ota16;

   584 		ota16.Copy (ota);

   585 		iEngine->Utils().LogIt ( _L("Comparison of content type (with charset parameter) failed -> %S"), &ota16 );	

   586 		User::Leave(KErrArgument);

   587 		}

   588 		

   589 	//

   590 	iEngine->Console().Printf(_L("\nTest encoding 'Content-Type' header (with two parameters)"));

   591 	hdr.RemoveField(contType);

   592 	ctVal.SetStrF(textWml);

   593 	chSet.SetStrF(utf8);

   594 	hdr.SetFieldL(contType, ctVal, iStrP.StringF(HTTP::ECharset,RHTTPSession::GetTable()), chSet);

   595 	chSet.SetStrF(extendVal);

   596 	hdr.SetFieldL(contType, ctVal, extended, chSet);

   597 	hdr.GetRawField(contType, ota);

   598 	if (ota.Compare(KContentTypeOTAVal3()) != 0)

   599 		{

   600 		TBuf<512> ota16;

   601 		ota16.Copy (ota);

   602 		iEngine->Utils().LogIt ( _L("Comparison of content type (with two parameters) field failed -> %S"), &ota16 );			

   603 		User::Leave(KErrArgument);

   604 		}

   605 		

   606 

   607 	ReleaseHeaders();

   608 	CleanupStack::PopAndDestroy(4,&usAscii);

   609 	iEngine->Utils().LogIt ( _L ("\nTestEncodeContentTypeL test success."));

   610 	}

   611 

   612 void CHttpHdrCodecTest::TestEncodeHostL()

   613 	{

   614 	_LIT8(KHostOTAVal1, "www.symbian.com"); // ota host header

   615 	_LIT8(KHostOTAVal2, "www.psion.com:8080"); // ota host header

   616 

   617 	// Open strings used in this test

   618 	RStringF host1Str = iStrP.OpenFStringL(_L8("www.symbian.com"));

   619 	CleanupClosePushL(host1Str);

   620 	RStringF host2Str = iStrP.OpenFStringL(_L8("www.psion.com"));

   621 	CleanupClosePushL(host2Str);

   622 	//

   623 	iEngine->Console().Printf(_L("\nTest encoding 'Host' header (no port)"));

   624 	RHTTPHeaders hdr = GetHeadersLC();

   625 	RStringF host = iStrP.StringF(HTTP::EHost,RHTTPSession::GetTable());

   626 	THTTPHdrVal hostVal(host1Str);

   627 	hdr.SetFieldL(host, hostVal);

   628 

   629 	// now get the OTA data

   630 	TPtrC8 ota;

   631 	hdr.GetRawField(host, ota);

   632 	if (ota.Compare(KHostOTAVal1()) != 0)

   633 		{

   634 		TBuf < 512 > ota16;

   635 		ota16.Copy ( ota );

   636 		

   637 		iEngine->Utils().LogIt ( _L("\nComparison of host field failed. -> %S"), &ota16 );		

   638 		User::Leave(KErrArgument);	

   639 		}

   640 	

   641 	//

   642 	iEngine->Console().Printf(_L("\nTest encoding 'Host' header (with port parameter)"));

   643 	hdr.RemoveField(host);

   644 	RStringF port = iStrP.StringF(HTTP::EPort,RHTTPSession::GetTable());

   645 	hostVal.SetStrF(host2Str);

   646 	THTTPHdrVal portNum(8080);

   647 	hdr.SetFieldL(host, hostVal, port, portNum);

   648 

   649 	// now get the OTA data

   650 	hdr.GetRawField(host, ota);

   651 	if (ota.Compare(KHostOTAVal2()) != 0)

   652 		{

   653 		TBuf < 512 > ota16;

   654 		ota16.Copy ( ota );

   655 		iEngine->Utils().LogIt ( _L("\nComparison of host (with port parameter) field failed -> %S"), &ota16 );

   656 		User::Leave(KErrArgument);

   657 		}

   658 		

   659 

   660 	ReleaseHeaders();

   661 

   662 	CleanupStack::PopAndDestroy(2,&host1Str);

   663 	iEngine->Utils().LogIt(_L("\nTestEncodeHostL test success."));

   664 	}

   665 

   666 void CHttpHdrCodecTest::TestEncodeTransferEncodingL()

   667 	{

   668 	// the result we expect and that we will validate

   669 	_LIT8(KTransferEncodingOTAVal, "chunked, another");

   670 

   671 	// Open strings used in this test

   672 	RStringF anotherToken = iStrP.OpenFStringL(_L8("another"));

   673 	CleanupClosePushL(anotherToken);

   674 	//

   675 	iEngine->Console().Printf(_L("\nTest encoding 'Transfer-Encoding' header"));

   676 	RHTTPHeaders hdr = GetHeadersLC();

   677 	RStringF trEncStr = iStrP.StringF(HTTP::ETransferEncoding,RHTTPSession::GetTable());

   678 	THTTPHdrVal trEncVal(iStrP.StringF(HTTP::EChunked,RHTTPSession::GetTable()));

   679 	hdr.SetFieldL(trEncStr, trEncVal); // sets part 1

   680 	trEncVal.SetStrF(anotherToken);

   681 	hdr.SetFieldL(trEncStr, trEncVal); // sets part 2

   682 

   683 	// now get the OTA data

   684 	TPtrC8 ota;

   685 	hdr.GetRawField(trEncStr, ota);

   686 	if(ota.Compare(KTransferEncodingOTAVal()) != 0)

   687 		{

   688 		TBuf < 512 > ota16;

   689 		ota16.Copy ( ota );

   690 		iEngine->Utils().LogIt ( _L("\nComparison of Transfer-Encoding field failed. -> %S"), &ota16 );

   691 		User::Leave(KErrArgument);

   692 		}

   693 		

   694 

   695 	ReleaseHeaders();

   696 

   697 	CleanupStack::PopAndDestroy(&anotherToken);

   698 	iEngine->Utils().LogIt ( _L ("\nTestEncodeTransferEncodingL test success."));

   699 	}

   700 

   701 void CHttpHdrCodecTest::TestEncodeUserAgentL()

   702 	{

   703  	// the result we expect and that we will validate

   704 	_LIT8(KUserAgentOTAVal, "CERN-LineMode/2.15 libwww/2.17b3");

   705 

   706 	// Open strings used in this test

   707 	RStringF ua1Str = iStrP.OpenFStringL(_L8("CERN-LineMode/2.15"));

   708 	CleanupClosePushL(ua1Str);

   709 	RStringF ua2Str = iStrP.OpenFStringL(_L8("libwww/2.17b3"));

   710 	CleanupClosePushL(ua2Str);

   711 	//

   712 	iEngine->Console().Printf(_L("\nTest encoding 'User-Agent' header"));

   713 	RHTTPHeaders hdr = GetHeadersLC();

   714 	RStringF uaStr = iStrP.StringF(HTTP::EUserAgent,RHTTPSession::GetTable());

   715 	THTTPHdrVal uaVal(ua1Str);

   716 	hdr.SetFieldL(uaStr, uaVal); // sets part 1

   717 	uaVal.SetStrF(ua2Str);

   718 	hdr.SetFieldL(uaStr, uaVal); // sets part 2

   719 

   720 	// now get the OTA data

   721 	TPtrC8 ota;

   722 	hdr.GetRawField(uaStr, ota);

   723 	if(ota.Compare(KUserAgentOTAVal()) != 0)

   724 		{

   725 		TBuf < 512 > ota16;

   726 		ota16.Copy ( ota );

   727 		iEngine->Utils().LogIt ( _L("\nComparison of User-Agent field failed. -> %S"), &ota16 );

   728 		User::Leave(KErrArgument);

   729 		}

   730 		

   731 	

   732 	ReleaseHeaders();

   733 

   734 	CleanupStack::PopAndDestroy(2,&ua1Str);

   735 	iEngine->Utils().LogIt ( _L ("\nTestEncodeUserAgentL test success."));

   736 	}

   737 

   738 void CHttpHdrCodecTest::TestEncodeCookieL()

   739 	{

   740 	_LIT8(KEncodedCookieHeader1, "CUSTOMER=WILE_E_COYOTE");

   741 	_LIT8(KEncodedCookieHeader2, "CUSTOMER=WILE_E_COYOTE; PART_NUMBER=ROCKETLAUNCHER_0001");

   742 	_LIT8(KEncodedCookieHeader3, "CUSTOMER=WILE_E_COYOTE; PART_NUMBER=ROCKETLAUNCHER_0001; SHIPPING=FEDEX");

   743 	_LIT8(KEncodedCookieHeader4, "$VERSION=1; CUSTOMER=WILE_E_COYOTE; $PATH=/");

   744 	

   745 	_LIT8(KName1, "CUSTOMER");

   746 	_LIT8(KValue1, "WILE_E_COYOTE");

   747 	_LIT8(KName2, "PART_NUMBER");

   748 	_LIT8(KValue2, "ROCKETLAUNCHER_0001");

   749 	_LIT8(KName3, "SHIPPING");

   750 	_LIT8(KValue3, "FEDEX");

   751 	_LIT8(KVersion, "1");

   752 	_LIT8(KPath, "/");

   753 

   754 	RString name1 = iStrP.OpenStringL(KName1);

   755 	CleanupClosePushL(name1);

   756 	RString value1 = iStrP.OpenStringL(KValue1);

   757 	CleanupClosePushL(value1);

   758 	RString name2 = iStrP.OpenStringL(KName2);

   759 	CleanupClosePushL(name2);

   760 	RString value2 = iStrP.OpenStringL(KValue2);

   761 	CleanupClosePushL(value2);	

   762 	RString name3 = iStrP.OpenStringL(KName3);

   763 	CleanupClosePushL(name3);	

   764 	RString value3 = iStrP.OpenStringL(KValue3);

   765 	CleanupClosePushL(value3);

   766 	RStringF version = iStrP.OpenFStringL(KVersion);

   767 	CleanupClosePushL(version);

   768 	RStringF path = iStrP.OpenFStringL(KPath);

   769 	CleanupClosePushL(path);

   770 

   771 	RStringF cookie = iStrP.StringF(HTTP::ECookie, RHTTPSession::GetTable());

   772 	RStringF cookieName = iStrP.StringF(HTTP::ECookieName, RHTTPSession::GetTable());

   773 	RStringF cookieValue = iStrP.StringF(HTTP::ECookieValue, RHTTPSession::GetTable());

   774 	RStringF cookieVersion = iStrP.StringF(HTTP::EVersion, RHTTPSession::GetTable());

   775 	RStringF cookiePath = iStrP.StringF(HTTP::EPath, RHTTPSession::GetTable());

   776 

   777 	TPtrC8 rawHeader;

   778 	RHTTPHeaders hdr = GetHeadersLC();

   779 

   780 	THTTPHdrVal hVal;

   781 	hdr.SetFieldL(cookie, THTTPHdrVal());

   782 	hVal.SetStr(name1);

   783 	hdr.SetParamL(cookie, cookieName, hVal, 0);

   784 	hVal.SetStr(value1);

   785 	hdr.SetParamL(cookie, cookieValue, hVal, 0);

   786 

   787 	hdr.GetRawField(cookie, rawHeader);

   788 	if (rawHeader.CompareF(KEncodedCookieHeader1) !=0)

   789 		{

   790 		TBuf < 1024> rawHeader16;

   791 		rawHeader16.Copy ( rawHeader );

   792 		

   793 		iEngine->Utils().LogIt ( _L("\nComparison of cookie header1 failed. -> %S"), &rawHeader16);		

   794 		User::Leave(KErrArgument);

   795 		}

   796 		

   797 

   798 	ReleaseHeaders();

   799 

   800 	hdr = GetHeadersLC();

   801 	hdr.SetFieldL(cookie, THTTPHdrVal());

   802 	hVal.SetStr(name1);

   803 	hdr.SetParamL(cookie, cookieName, hVal, 0);

   804 	hVal.SetStr(value1);

   805 	hdr.SetParamL(cookie, cookieValue, hVal, 0);

   806 	hVal.SetStr(name2);

   807 	hdr.SetParamL(cookie, cookieName, hVal, 0);

   808 	hVal.SetStr(value2);

   809 	hdr.SetParamL(cookie, cookieValue, hVal, 0);

   810 

   811 	hdr.GetRawField(cookie, rawHeader);

   812 	if (rawHeader.CompareF(KEncodedCookieHeader2) !=0)

   813 		{

   814 		TBuf < 1024> rawHeader16;

   815 		rawHeader16.Copy ( rawHeader );

   816 

   817 		iEngine->Utils().LogIt ( _L("\nComparison of cookie header2 failed. -> %S"), &rawHeader16);

   818 		User::Leave(KErrArgument);

   819 		}

   820 		

   821 

   822 	ReleaseHeaders();

   823 

   824 	hdr = GetHeadersLC();

   825 	hdr.SetFieldL(cookie, THTTPHdrVal());

   826 	hVal.SetStr(name1);

   827 	hdr.SetParamL(cookie, cookieName, hVal, 0);

   828 	hVal.SetStr(value1);

   829 	hdr.SetParamL(cookie, cookieValue, hVal, 0);

   830 	hVal.SetStr(name2);

   831 	hdr.SetParamL(cookie, cookieName, hVal, 0);

   832 	hVal.SetStr(value2);

   833 	hdr.SetParamL(cookie, cookieValue, hVal, 0);

   834 	hVal.SetStr(name3);

   835 	hdr.SetParamL(cookie, cookieName, hVal, 0);

   836 	hVal.SetStr(value3);

   837 	hdr.SetParamL(cookie, cookieValue, hVal, 0);

   838 

   839 	hdr.GetRawField(cookie, rawHeader);

   840 	if (rawHeader.CompareF(KEncodedCookieHeader3) !=0)

   841 		{

   842 		TBuf < 1024> rawHeader16;

   843 		rawHeader16.Copy ( rawHeader );

   844 		

   845 		iEngine->Utils().LogIt ( _L("\nComparison of cookie header3 failed %S"), &rawHeader16 );

   846 		User::Leave(KErrArgument);

   847 		}

   848 		

   849 	ReleaseHeaders();

   850 

   851 	hdr = GetHeadersLC();

   852 	hdr.SetFieldL(cookie, THTTPHdrVal());

   853 	hVal.SetStr(name1);

   854 	hdr.SetParamL(cookie, cookieName, hVal, 0);

   855 	hVal.SetStr(value1);

   856 	hdr.SetParamL(cookie, cookieValue, hVal, 0);

   857 	hVal.SetStr(name2);

   858 	hdr.SetParamL(cookie, cookieName, hVal, 0);

   859 	hVal.SetStr(value2);

   860 	hdr.SetParamL(cookie, cookieValue, hVal, 0);

   861 	hVal.SetStr(name3);

   862 	hdr.SetParamL(cookie, cookieName, hVal, 0);

   863 	hVal.SetStr(value3);

   864 	hdr.SetParamL(cookie, cookieValue, hVal, 0);

   865 

   866 	hdr.GetRawField(cookie, rawHeader);

   867 	if (rawHeader.CompareF(KEncodedCookieHeader3) !=0)

   868 		{

   869 		TBuf < 1024> rawHeader16;

   870 		rawHeader16.Copy ( rawHeader );

   871 		

   872 		iEngine->Utils().LogIt ( _L("\nComparison of cookie header4 failed %S"), &rawHeader16 );

   873 		User::Leave(KErrArgument);

   874 		}	

   875 	ReleaseHeaders();

   876 

   877 	hdr = GetHeadersLC();

   878 	hdr.SetFieldL(cookie, THTTPHdrVal());

   879 	hVal.SetStrF(version);

   880 	hdr.SetParamL(cookie, cookieVersion, hVal, 0);

   881 	hVal.SetStr(name1);

   882 	hdr.SetParamL(cookie, cookieName, hVal, 0);

   883 	hVal.SetStr(value1);

   884 	hdr.SetParamL(cookie, cookieValue, hVal, 0);

   885 	hVal.SetStrF(path);

   886 	hdr.SetParamL(cookie, cookiePath, hVal, 0);

   887 	

   888 	hdr.GetRawField(cookie, rawHeader);

   889 	if (rawHeader.CompareF(KEncodedCookieHeader4) !=0)

   890 		{

   891 		TBuf < 1024> rawHeader16;

   892 		rawHeader16.Copy ( rawHeader );

   893 		

   894 		iEngine->Utils().LogIt ( _L("\nComparison of cookie header5 failed  -> %S"), &rawHeader16);

   895 		User::Leave(KErrArgument);

   896 		}

   897 		

   898 

   899 	ReleaseHeaders();

   900 	

   901 	CleanupStack::PopAndDestroy(8,&name1);

   902 	iEngine->Utils().LogIt ( _L ("\nTestEncodeCookieL test success."));

   903 	}

   904 

   905 void CHttpHdrCodecTest::TestDecodeSetCookieL()

   906 	{

   907 	RStringF setCookie = iStrP.StringF(HTTP::ESetCookie,RHTTPSession::GetTable());

   908 

   909 	RStringF cookieName = iStrP.StringF(HTTP::ECookieName,RHTTPSession::GetTable());

   910 	RStringF cookieValue= iStrP.StringF(HTTP::ECookieValue,RHTTPSession::GetTable());

   911 	RStringF cookiePath= iStrP.StringF(HTTP::EPath,RHTTPSession::GetTable());

   912 	RStringF cookieExpires= iStrP.StringF(HTTP::EExpires,RHTTPSession::GetTable());

   913 

   914 	THTTPHdrVal hdrVal;

   915 	RHTTPHeaders hdr = GetHeadersLC();

   916 	_LIT8(KEncodedCookie1, "CUSTOMER=WILE_E_COYOTE; path=/; expires=Wednesday, 09-Nov-99 23");

   917 	_LIT8(KCookie1Name, "CUSTOMER");

   918 	_LIT8(KCookie1Value, "WILE_E_COYOTE"); 

   919 	_LIT8(KCookie1Path, "/"); 

   920 	_LIT8(KCookie1Expires, "Wednesday, 09-Nov-99 23");

   921 

   922 	RString cookie1Name = iStrP.OpenStringL(KCookie1Name);

   923 	CleanupClosePushL(cookie1Name);

   924 	RString cookie1Value = iStrP.OpenStringL(KCookie1Value);

   925 	CleanupClosePushL(cookie1Value);

   926 	RStringF cookie1Path = iStrP.OpenFStringL(KCookie1Path);

   927 	CleanupClosePushL(cookie1Path);

   928 	RStringF cookie1Expires = iStrP.OpenFStringL(KCookie1Expires);

   929 	CleanupClosePushL(cookie1Expires);

   930 

   931 	hdr.SetRawFieldL(setCookie, KEncodedCookie1, KFieldSeparator); 

   932 	User::LeaveIfError(hdr.GetParam(setCookie, cookieName, hdrVal));

   933 	if (!(hdrVal.Type() == THTTPHdrVal::KStrVal && hdrVal.Str() == cookie1Name))

   934 		{

   935 		iEngine->Utils().LogIt ( _L("\nComparison of cookie1Name failed. -> %d,%d"), hdrVal.Type() == THTTPHdrVal::KStrFVal, hdrVal.Str() == cookie1Name );

   936 		User::Leave(KErrArgument);

   937 		}

   938 		

   939 	User::LeaveIfError(hdr.GetParam(setCookie, cookieValue, hdrVal));

   940 	if (!(hdrVal.Type() == THTTPHdrVal::KStrVal && hdrVal.Str() == cookie1Value))

   941 		{

   942 		iEngine->Utils().LogIt ( _L("\nComparison of cookie1Value failed. -> %d,%d"), hdrVal.Type() == THTTPHdrVal::KStrFVal, hdrVal.Str() == cookie1Value );

   943 		User::Leave(KErrArgument);

   944 		}

   945 		

   946 	User::LeaveIfError(hdr.GetParam(setCookie, cookieExpires, hdrVal));

   947 	if (!(hdrVal.Type() == THTTPHdrVal::KStrFVal && hdrVal.StrF() == cookie1Expires))

   948 		{

   949 		iEngine->Utils().LogIt ( _L("\nComparison of cookie1Expires failed -> %d,%d"), hdrVal.Type() == THTTPHdrVal::KStrFVal, hdrVal.StrF() == cookie1Expires );

   950 		User::Leave(KErrArgument);

   951 		}

   952 		

   953 	User::LeaveIfError(hdr.GetParam(setCookie, cookiePath, hdrVal));

   954 	if (!(hdrVal.Type() == THTTPHdrVal::KStrFVal && hdrVal.StrF() == cookie1Path))

   955 		{

   956 		iEngine->Utils().LogIt ( _L("\nComparison of cookie1Path failed -> %d,%d"), hdrVal.Type() == THTTPHdrVal::KStrFVal, hdrVal.StrF() == cookie1Path );

   957 		User::Leave(KErrArgument);

   958 		}

   959 		

   960 

   961 	CleanupStack::PopAndDestroy(4,&cookie1Name); // cookie1Expires, cookie1Path, cookie1Value, cookie1Name

   962 	ReleaseHeaders();

   963 

   964 	hdr = GetHeadersLC();

   965 	_LIT8(KEncodedCookie2, "PART_NUMBER=ROCKETLAUNCHER_0001; path=/");

   966 	_LIT8(KCookie2Name, "PART_NUMBER");

   967 	_LIT8(KCookie2Value, "ROCKETLAUNCHER_0001");

   968 	_LIT8(KCookie2Path, "/");	

   969 

   970 	RString cookie2Name = iStrP.OpenStringL(KCookie2Name);

   971 	CleanupClosePushL(cookie2Name);

   972 	RString cookie2Value = iStrP.OpenStringL(KCookie2Value);

   973 	CleanupClosePushL(cookie2Value);

   974 	RStringF cookie2Path = iStrP.OpenFStringL(KCookie2Path);

   975 	CleanupClosePushL(cookie2Path);

   976 

   977 	hdr.SetRawFieldL(setCookie, KEncodedCookie2, KFieldSeparator); 

   978 	User::LeaveIfError(hdr.GetParam(setCookie, cookieName, hdrVal));

   979 	if (!(hdrVal.Type() == THTTPHdrVal::KStrVal && hdrVal.Str() == cookie2Name))

   980 		{

   981 		iEngine->Utils().LogIt ( _L("\nComparison of cookie2Name failed -> %d,%d"), hdrVal.Type() == THTTPHdrVal::KStrFVal, hdrVal.Str() == cookie2Name );

   982 		User::Leave(KErrArgument);

   983 		}

   984 		

   985 	User::LeaveIfError(hdr.GetParam(setCookie, cookieValue, hdrVal));

   986 	if (!(hdrVal.Type() == THTTPHdrVal::KStrVal && hdrVal.Str() == cookie2Value))

   987 		{

   988 		iEngine->Utils().LogIt ( _L("\nComparison of cookie2Value failed  -> %d,%d"), hdrVal.Type() == THTTPHdrVal::KStrFVal, hdrVal.Str() == cookie2Value );

   989 		User::Leave(KErrArgument);

   990 		}

   991 		

   992 	User::LeaveIfError(hdr.GetParam(setCookie, cookiePath, hdrVal));

   993 	if (!(hdrVal.Type() == THTTPHdrVal::KStrFVal && hdrVal.StrF() == cookie2Path))

   994 		{

   995 		iEngine->Utils().LogIt ( _L("\nComparison of cookie2Path failed -> %d,%d"), hdrVal.Type() == THTTPHdrVal::KStrFVal, hdrVal.StrF() == cookie2Path );

   996 		User::Leave(KErrArgument);	

   997 		}

   998 	

   999 

  1000 	CleanupStack::PopAndDestroy(3, &cookie2Name); // cookie2Path, cookie2Value, cookie2Name;

  1001 	ReleaseHeaders();

  1002 	

  1003 	hdr = GetHeadersLC();	

  1004 	_LIT8(KEncodedCookie3, " SHIPPING=FEDEX; path=/foo");

  1005 	_LIT8(KCookie3Name, "SHIPPING");

  1006 	_LIT8(KCookie3Value, "FEDEX");

  1007 	_LIT8(KCookie3Path, "/foo");

  1008 

  1009 	RString cookie3Name = iStrP.OpenStringL(KCookie3Name);

  1010 	CleanupClosePushL(cookie3Name);

  1011 	RString cookie3Value = iStrP.OpenStringL(KCookie3Value);

  1012 	CleanupClosePushL(cookie3Value);

  1013 	RStringF cookie3Path = iStrP.OpenFStringL(KCookie3Path);

  1014 	CleanupClosePushL(cookie3Path);

  1015 	hdr.SetRawFieldL(setCookie, KEncodedCookie3, KFieldSeparator); 

  1016 	

  1017 	User::LeaveIfError(hdr.GetParam(setCookie, cookieName, hdrVal));

  1018 	if (!(hdrVal.Type() == THTTPHdrVal::KStrVal && hdrVal.Str() == cookie3Name))

  1019 		{

  1020 		iEngine->Utils().LogIt ( _L("\nComparison of cookie3Name failed -> %d,%d"), hdrVal.Type() == THTTPHdrVal::KStrVal, hdrVal.Str() == cookie3Name );

  1021 		User::Leave(KErrArgument);

  1022 		}

  1023 		

  1024 	User::LeaveIfError(hdr.GetParam(setCookie, cookieValue, hdrVal));

  1025 	if (!(hdrVal.Type() == THTTPHdrVal::KStrVal && hdrVal.Str() == cookie3Value))

  1026 		{

  1027 		iEngine->Utils().LogIt ( _L("\nComparison of cookie3Value failed -> %d,%d"), hdrVal.Type() == THTTPHdrVal::KStrVal, hdrVal.Str() == cookie3Value );

  1028 		User::Leave(KErrArgument);

  1029 		}

  1030 		

  1031 	User::LeaveIfError(hdr.GetParam(setCookie, cookiePath, hdrVal));

  1032 	if (!(hdrVal.Type() == THTTPHdrVal::KStrFVal && hdrVal.StrF() == cookie3Path))

  1033 		{

  1034 		iEngine->Utils().LogIt ( _L("\nComparison of cookie3Path failed -> %d,%d"), hdrVal.Type() == THTTPHdrVal::KStrFVal, hdrVal.StrF() == cookie3Path );

  1035 		User::Leave(KErrArgument);

  1036 		}

  1037 		

  1038 

  1039 	CleanupStack::PopAndDestroy(3,&cookie3Name); //cookie3Path, cookie3Value, cookie3Name

  1040 	ReleaseHeaders();

  1041 	iEngine->Utils().LogIt ( _L ("\nTestDecodeSetCookieL test success."));

  1042 	}

  1043 

  1044 void CHttpHdrCodecTest::TestDecodeSetCookie2L()

  1045 	{

  1046 	RStringF setCookie = iStrP.StringF(HTTP::ESetCookie2, RHTTPSession::GetTable());

  1047 

  1048 	RStringF cookieName = iStrP.StringF(HTTP::ECookieName, RHTTPSession::GetTable());

  1049 	RStringF cookieValue= iStrP.StringF(HTTP::ECookieValue, RHTTPSession::GetTable());

  1050 	RStringF cookiePath= iStrP.StringF(HTTP::EPath, RHTTPSession::GetTable());

  1051 	RStringF cookieMaxAge= iStrP.StringF(HTTP::EMaxAge, RHTTPSession::GetTable());

  1052 	RStringF cookiePort= iStrP.StringF(HTTP::ECookiePort, RHTTPSession::GetTable());

  1053 	RStringF cookieComment= iStrP.StringF(HTTP::EComment, RHTTPSession::GetTable());

  1054 	RStringF cookieCommentURL= iStrP.StringF(HTTP::ECommentURL, RHTTPSession::GetTable());

  1055 	RStringF cookieSecure= iStrP.StringF(HTTP::ESecure, RHTTPSession::GetTable());

  1056 	RStringF cookieDiscard= iStrP.StringF(HTTP::EDiscard, RHTTPSession::GetTable());

  1057 

  1058 	THTTPHdrVal hdrVal;

  1059 	RHTTPHeaders hdr = GetHeadersLC();

  1060 	_LIT8(KEncodedCookie1, 

  1061 		"CUSTOMER=WILE_E_COYOTE; path=/; max-age=0; port=\"80,8000\"; comment=This is a cookie; commentURL=http://www.cookie.com; secure; discard");

  1062 	_LIT8(KCookie1Name, "CUSTOMER");

  1063 	_LIT8(KCookie1Value, "WILE_E_COYOTE"); 

  1064 	_LIT8(KCookie1Path, "/"); 

  1065 	_LIT8(KCookie1MaxAge, "0");

  1066 	_LIT8(KCookie1Port, "\"80,8000\"");

  1067 	_LIT8(KCookie1Comment, "This is a cookie");

  1068 	_LIT8(KCookie1CommentURL, "http://www.cookie.com");

  1069 

  1070 	RString cookie1Name = iStrP.OpenStringL(KCookie1Name);

  1071 	CleanupClosePushL(cookie1Name);

  1072 	RString cookie1Value = iStrP.OpenStringL(KCookie1Value);

  1073 	CleanupClosePushL(cookie1Value);

  1074 	RStringF cookie1Path = iStrP.OpenFStringL(KCookie1Path);

  1075 	CleanupClosePushL(cookie1Path);

  1076 	RStringF cookie1MaxAge = iStrP.OpenFStringL(KCookie1MaxAge);

  1077 	CleanupClosePushL(cookie1MaxAge);

  1078 	RStringF cookie1Port = iStrP.OpenFStringL(KCookie1Port);

  1079 	CleanupClosePushL(cookie1Port);

  1080 	RStringF cookie1Comment = iStrP.OpenFStringL(KCookie1Comment);

  1081 	CleanupClosePushL(cookie1Comment);

  1082 	RStringF cookie1CommentURL = iStrP.OpenFStringL(KCookie1CommentURL);

  1083 	CleanupClosePushL(cookie1CommentURL);

  1084 

  1085 	hdr.SetRawFieldL(setCookie, KEncodedCookie1, KFieldSeparator); 

  1086 	User::LeaveIfError(hdr.GetParam(setCookie, cookieName, hdrVal));

  1087 	if (!(hdrVal.Type() == THTTPHdrVal::KStrVal && hdrVal.Str() == cookie1Name))

  1088 		{

  1089 		iEngine->Utils().LogIt ( _L("\nComparison of cookie1Name & hdr type failed  -> %d,%d"), hdrVal.Type() == THTTPHdrVal::KStrVal, hdrVal.Str() == cookie1Name );

  1090 		User::Leave(KErrArgument);

  1091 		}

  1092 		

  1093 	User::LeaveIfError(hdr.GetParam(setCookie, cookieValue, hdrVal));

  1094 	if (!(hdrVal.Type() == THTTPHdrVal::KStrVal && hdrVal.Str() == cookie1Value))

  1095 		{

  1096 		iEngine->Utils().LogIt ( _L("\nComparison of cookie1Value & hdr type failed -> %d,%d"), hdrVal.Type() == THTTPHdrVal::KStrVal, hdrVal.Str() == cookie1Value );

  1097 		User::Leave(KErrArgument);

  1098 		}

  1099 		

  1100 	User::LeaveIfError(hdr.GetParam(setCookie, cookieMaxAge, hdrVal));

  1101 	if (!(hdrVal.Type() == THTTPHdrVal::KStrFVal && hdrVal.StrF() == cookie1MaxAge))

  1102 		{

  1103 		iEngine->Utils().LogIt ( _L("\nComparison of cookie1MaxAge & hdr type failed -> %d,%d"), hdrVal.Type() == THTTPHdrVal::KStrFVal, hdrVal.StrF() == cookie1MaxAge );

  1104 		User::Leave(KErrArgument);

  1105 		}

  1106 		

  1107 	User::LeaveIfError(hdr.GetParam(setCookie, cookiePort, hdrVal));

  1108 	if (!(hdrVal.Type() == THTTPHdrVal::KStrFVal && hdrVal.StrF() == cookie1Port))

  1109 		{

  1110 		iEngine->Utils().LogIt ( _L("\nComparison of cookie1Port & hdr type failed -> %d,%d"), hdrVal.Type() == THTTPHdrVal::KStrFVal, hdrVal.StrF() == cookie1Port );

  1111 		User::Leave(KErrArgument);

  1112 		}

  1113 		

  1114 	User::LeaveIfError(hdr.GetParam(setCookie, cookiePath, hdrVal));

  1115 	if (!(hdrVal.Type() == THTTPHdrVal::KStrFVal && hdrVal.StrF() == cookie1Path))

  1116 		{

  1117 		iEngine->Utils().LogIt ( _L("\nComparison of cookie1Path & hdr type failed -> %d,%d"), hdrVal.Type() == THTTPHdrVal::KStrFVal, hdrVal.StrF() == cookie1Path );

  1118 		User::Leave(KErrArgument);

  1119 		}

  1120 		

  1121 	User::LeaveIfError(hdr.GetParam(setCookie, cookieComment, hdrVal));

  1122 	if (!(hdrVal.Type() == THTTPHdrVal::KStrFVal && hdrVal.StrF() == cookie1Comment))

  1123 		{

  1124 		iEngine->Utils().LogIt ( _L("\nComparison of cookie1Comment & hdr type failed -> %d,%d"), hdrVal.Type() == THTTPHdrVal::KStrFVal, hdrVal.StrF() == cookie1Comment );

  1125 		User::Leave(KErrArgument);		

  1126 		}

  1127 		

  1128 	User::LeaveIfError(hdr.GetParam(setCookie, cookieCommentURL, hdrVal));

  1129 	if (!(hdrVal.Type() == THTTPHdrVal::KStrFVal && hdrVal.StrF() == cookie1CommentURL))

  1130 		{

  1131 		iEngine->Utils().LogIt ( _L("\nComparison of cookie1CommentURL & hdr type failed -> %d,%d"), hdrVal.Type() == THTTPHdrVal::KStrFVal, hdrVal.StrF() == cookie1CommentURL );

  1132 		User::Leave(KErrArgument);

  1133 		}

  1134