1 // Copyright (c) 2008-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 //

    15 

    16 #include <http/framework/cheadercodecplugin.h>

    17 #include <ecom/ecom.h>

    18 #include <http/thttptable.h>

    19 #include <upnp/tupnptable.h>

    20 

    21 #include "ccodecdecodetest.h"

    22 

    23 _LIT8(KHeaderSeparator,	"\n");

    24 

    25 _LIT8(KUpnpCodecName, "HTTP/UPnP");

    26 _LIT(KTestName, "CODEC_TEST_1");

    27 

    28 

    29 CCodecDecodeTest* CCodecDecodeTest::NewL()

    30 	{

    31 	return (new(ELeave)CCodecDecodeTest());

    32 	}

    33 

    34 

    35 CCodecDecodeTest::CCodecDecodeTest()

    36 	{

    37 	SetTestStepName(KCodecDecodeTest);

    38 	}

    39 

    40 

    41 CCodecDecodeTest::~CCodecDecodeTest()

    42 	{

    43 	}

    44 

    45 

    46 TVerdict CCodecDecodeTest::doTestStepPreambleL()

    47 	{

    48 	iSched = new(ELeave) CActiveScheduler;

    49 	CActiveScheduler::Install(iSched);

    50 

    51 	iPool.OpenL(TUPnPTable::Table());

    52 	iPool.OpenL(THTTPTable::Table());

    53 	

    54 	iCodec = NULL;

    55 	iRequest = NULL;

    56 	iResponse = NULL;

    57 	iReqParser = NULL;

    58 	iRespParser = NULL;

    59 

    60 	return TestStepResult();

    61 	}

    62 

    63 

    64 TVerdict CCodecDecodeTest::doTestStepL()

    65 	{

    66 	TInt noOfHdrValPairs;

    67 	TBool requestHeader;

    68 	

    69 	if(!GetIntFromConfig(ConfigSection(), KNoOfHdrValPairs, noOfHdrValPairs) ||

    70 		!GetBoolFromConfig(ConfigSection(), KRequestHeader, requestHeader)

    71 		)

    72 		{

    73 		ERR_PRINTF3(_L("===> Problem in reading values from ini.			\

    74 				\nExpected fields are: \n%S\n%S <==="

    75 			  ), &KNoOfHdrValPairs, &KRequestHeader);

    76 		

    77 		SetTestStepResult(EFail);

    78 		return TestStepResult();

    79 		}

    80 

    81   	if(requestHeader)

    82   		{

    83   		// has to load the server codec

    84   		iCodec = CHeaderCodecPlugin::NewL(KUpnpCodecName, iPool);

    85   		iRequest = CRequest::NewL(*iCodec, iPool);

    86   		iRHeaders = iRequest->Handle().GetHeaderCollection();

    87   		iReqParser = CUpnpRequestParser::NewL(*this);

    88   		}

    89   	else

    90   		{

    91   		// has to load the client codec

    92   		iCodec = CHeaderCodecPlugin::NewL(KUpnpCodecName, iPool);

    93   		iResponse = CResponse::NewL(*iCodec, iPool);

    94   		iRHeaders = iResponse->Handle().GetHeaderCollection();

    95   		iRespParser = CUpnpResponseParser::NewL(*this);

    96   		}

    97 

    98 	TRAPD(err, ConstructHeadersL(noOfHdrValPairs));

    99 	if(err != KErrNone)

   100 		{

   101 		SetTestStepResult(EFail);

   102 		return TestStepResult();

   103 		}

   104 

   105 	TRAP(err, GetFieldL());

   106 	if(err != KErrNone)

   107 		{

   108 		SetTestStepResult(EFail);

   109 		return TestStepResult();

   110 		}

   111 		

   112 	// The follwoing section of code has been written for code coverage.

   113 	if(ConfigSection().Compare(KTestName())== 0)

   114 		{

   115 		RStringF s = iPool.StringF(HTTP::EAccept, THTTPTable::Table());

   116 		_LIT8(KSomeVal, "some");

   117 		iRHeaders.SetRawFieldL(s, KSomeVal, KHeaderSeparator);

   118 		THTTPHdrVal aV;

   119 		iRHeaders.GetField(s,0,aV);

   120 		iRHeaders.RemoveField(s);

   121 		

   122 		RStringF m = iPool.StringF(UPnP::EMAN, TUPnPTable::Table());

   123 		iRHeaders.RemoveField(m);

   124 		_LIT8(KSomeMan, "ns=01");

   125 		iRHeaders.SetRawFieldL(m, KSomeMan(), KHeaderSeparator);

   126 		THTTPHdrVal mV;

   127 		iRHeaders.GetField(m, 0, mV);

   128 		iRHeaders.RemoveField(m);

   129 		

   130 		_LIT8(KSomeMan2, "some;ns=01;=;;");

   131 		iRHeaders.SetRawFieldL(m, KSomeMan2(), KHeaderSeparator);

   132 		iRHeaders.GetField(m, 0, mV);

   133 		iRHeaders.RemoveField(m);

   134 		

   135 		if(requestHeader)

   136 			{

   137 			RStringF accept = iPool.StringF(HTTP::EAccept, THTTPTable::Table());

   138 			RStringF textHtml = iPool.StringF(HTTP::ETextHtml, THTTPTable::Table());

   139 			RStringF textPlain = iPool.StringF(HTTP::ETextPlain, THTTPTable::Table());

   140 			RStringF eQ = iPool.StringF(HTTP::EQ, THTTPTable::Table());

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

   142 			

   143 			RStringF expect = iPool.StringF(HTTP::EExpect, THTTPTable::Table());

   144 			RStringF so = iPool.OpenFStringL(_L8("some"));

   145 			CleanupClosePushL(so);

   146 			iRHeaders.FieldPartsL(expect);

   147 			THTTPHdrVal x;

   148 			iRHeaders.GetParam(so, textHtml, x, 0);

   149 			CleanupStack::PopAndDestroy(&so);

   150 			TPtrC8 pt;

   151 			iRHeaders.GetRawField(expect, pt);

   152 			iRHeaders.RemoveField(expect);

   153 			iRHeaders.RemoveField(expect);

   154 			iRHeaders.RemoveFieldPart(expect, 0);

   155 			

   156 			iRHeaders.SetFieldL(accept, THTTPHdrVal(textHtml));

   157 			iRHeaders.SetFieldL(accept, THTTPHdrVal(textPlain));

   158 			iRHeaders.RemoveFieldPart(accept, 0);

   159 			iRHeaders.RemoveFieldPart(accept, 0);

   160 			iRHeaders.RemoveField(accept);

   161 			

   162 			TRAP(err, iRHeaders.SetFieldL(accept, textHtml, eQ, q));

   163 			if(err != KErrNone)

   164 				{

   165 				SetTestStepResult(EFail);

   166 				return TestStepResult();

   167 				}

   168 				

   169 			TRAP(err, iRHeaders.SetFieldL(accept, textPlain));	

   170 			if(err != KErrNone)

   171 				{

   172 				SetTestStepResult(EFail);

   173 				return TestStepResult();

   174 				}

   175 				

   176 			THTTPHdrFieldIter iter = iRHeaders.Fields();

   177 			while(!iter.AtEnd())

   178 				{

   179 				iter();

   180 				++iter;	

   181 				}

   182 				

   183 			++iter;

   184 			iter();	

   185 				

   186 			THTTPHdrVal q2;

   187 			iRHeaders.GetParam(accept, eQ, q2, 0);

   188 			if((q == q2))

   189 				{

   190 				if(q != q2)

   191 					{

   192 					// do nothing.	

   193 					}

   194 				iRHeaders.RemoveFieldPart(accept, 0);	

   195 				}

   196 				

   197 			TRAP(err, iRHeaders.SetFieldL(accept, textHtml, eQ, q));

   198 			if(err != KErrNone)

   199 				{

   200 				SetTestStepResult(EFail);

   201 				return TestStepResult();

   202 				}

   203 				iRHeaders.GetParam(accept, eQ, q2, 1);

   204 	

   205 			RString someString = iPool.OpenStringL(_L8("some"));

   206 			CleanupClosePushL(someString);

   207 			THTTPHdrVal v(someString);

   208 			v.SetStr(someString);

   209 			THTTPHdrVal t;

   210 			t = v.Copy();

   211 			someString = v.Str();

   212 		

   213 			THTTPHdrVal s(someString);

   214 			CleanupStack::PopAndDestroy(&someString);

   215 			if(s == v)

   216 				{

   217 				// do nothing.	

   218 				}

   219 				

   220 			TDateTime date(2008, EJune, 24, 9, 0, 0, 0);

   221 			TDateTime date2(2007, EJune, 23, 9, 0, 0, 0);

   222 			THTTPHdrVal dVal(date);

   223 			THTTPHdrVal dVal3(date2);

   224 			dVal.SetDateTime(date);

   225 			date = dVal.DateTime();

   226 			THTTPHdrVal dVal2;

   227 			dVal2 = dVal.Copy();

   228 			if(dVal == dVal2)

   229 				{

   230 				// do nothing.	

   231 				}

   232 			if(dVal == dVal3)

   233 				{

   234 				// do nothing.

   235 				}

   236 			

   237 			THTTPHdrVal strFVal, strFVal1;

   238 			strFVal.SetStrF(eQ);

   239 			strFVal1 = strFVal.Copy();

   240 			if(strFVal == strFVal1)

   241 				{

   242 				// do nothing.				

   243 				}

   244 				

   245 			THTTPHdrVal sVal;

   246 			THTTPHdrVal sVal2;

   247 			if(sVal == dVal)

   248 				{

   249 				// do nothing.			

   250 				}

   251 			if(dVal == sVal)

   252 				{

   253 				// do nothing.	

   254 				}

   255 			

   256 			if(ConfigSection().Compare(KTestName()) == 0)

   257 				{

   258 				if(sVal == sVal2)

   259 					{

   260 					// do nothing.

   261 					}

   262 				}

   263 			}

   264 		}

   265 	SetTestStepResult(EPass);	

   266 	return TestStepResult();

   267 	}

   268 

   269 

   270 TVerdict CCodecDecodeTest::doTestStepPostambleL()

   271 	{

   272 	if(iRequest)

   273 		delete iRequest;

   274 	

   275 	if(iResponse)

   276 		delete iResponse;

   277 	

   278 	iPool.Close();

   279 	

   280 	if(iRespParser)

   281 		delete iRespParser;

   282 	

   283 	if(iReqParser)

   284 		delete iReqParser;

   285 

   286 	delete iCodec;

   287 	delete iSched;

   288 

   289 	REComSession::FinalClose();

   290 	

   291 	return TestStepResult();

   292 	}

   293 

   294 

   295 void CCodecDecodeTest::ConstructHeadersL(const TInt aNoOfHdrValPairs)

   296 	{

   297 	// Create the "Header: Value" pair array.

   298 	TInt headersCounter = 1;

   299 	while(headersCounter <= aNoOfHdrValPairs)

   300 		{

   301 		TPtrC headerValuePair;

   302 		TBuf<20> buf(KNullDesC);

   303 		

   304 		// The below line is to create formats such as

   305 		// HeaderValuePair1, HeaderValuePair2...

   306 		buf.Format(KHeaderValuePair, headersCounter);

   307 		

   308 		GetStringFromConfig(ConfigSection(), buf, headerValuePair);

   309 		HBufC8* headerValPairBuf;

   310 		headerValPairBuf = CnvUtfConverter::ConvertFromUnicodeToUtf8L(headerValuePair);

   311 		CleanupStack::PushL(headerValPairBuf);

   312 		

   313 		TPtrC8 headerValPairPtr(headerValPairBuf->Des());

   314 		TInt consumed = headerValPairPtr.Locate(colon);

   315 		User::LeaveIfError(consumed);

   316 		

   317 		// Get the header. i.e, the string before the ':'

   318 		TPtrC8 header = headerValPairPtr.Left(consumed);

   319 		

   320 		headerValPairPtr.Set(headerValPairPtr.Mid(consumed+1));

   321 		InetProtTextUtils::RemoveWhiteSpace(headerValPairPtr, InetProtTextUtils::ERemoveBoth);

   322 		

   323 		// The left over data is the value for the header.

   324 		SetHeaderL(header, headerValPairPtr);

   325 		CleanupStack::PopAndDestroy(headerValPairBuf);

   326 		

   327 		headersCounter++;

   328 		}

   329 	}

   330 

   331 

   332 void CCodecDecodeTest::SetHeaderL(const TDesC8& aHeader, const TDesC8& aValue)

   333 	{

   334 	RStringF name = iPool.OpenFStringL(aHeader);

   335 	CleanupClosePushL(name);

   336 	iRHeaders.SetRawFieldL(name, aValue, KHeaderSeparator);

   337 	CleanupStack::PopAndDestroy(&name);

   338 	}

   339 

   340 

   341 void CCodecDecodeTest::GetFieldL()

   342 	{

   343 	TBuf<KMaxHeaderNameLen>  fieldName16;

   344 	TBuf<KMaxHeaderValueLen> fieldVal16;

   345 	THTTPHdrFieldIter iter = iRHeaders.Fields();

   346 

   347 	while(iter.AtEnd() == EFalse)

   348 		{

   349 		RStringTokenF fldName = iter();

   350 		RStringF headerSF = iPool.StringF(fldName);

   351 		THTTPHdrVal hdrVal;

   352 		

   353 		TInt partsIter = 0;

   354 		

   355 		FOREVER

   356 			{

   357 			if(iRHeaders.GetField(headerSF, partsIter, hdrVal) == KErrNone)

   358 				{

   359 				const TDesC8& fieldNameDesC = headerSF.DesC();

   360 				fieldName16.Copy(fieldNameDesC.Left(KMaxHeaderNameLen));

   361 				

   362 				switch(hdrVal.Type())

   363 					{

   364 					case THTTPHdrVal::KTIntVal:

   365 						INFO_PRINTF3(_L("\n===> %S: %u <==="), &fieldName16, hdrVal.Int());

   366 						break;

   367 					case THTTPHdrVal::KStrFVal:

   368 						const TDesC8& fieldValDesC = hdrVal.StrF().DesC();

   369 						fieldVal16.Copy(fieldValDesC.Left(KMaxHeaderValueLen));

   370 						INFO_PRINTF3(_L("\n===> %S: %S <==="), &fieldName16, &fieldVal16);

   371 						break;

   372 					}

   373 				}

   374 			else

   375 				{

   376 				break;	

   377 				}

   378 			++partsIter;		

   379 			}

   380 		++iter;	

   381 		}

   382 	}

   383 

   384 

   385 void CCodecDecodeTest::GotBodyData()

   386 	{

   387 	User::Invariant();

   388 	}

   389 

   390 

   391 void CCodecDecodeTest::DataParsed()

   392 	{

   393 	User::Invariant();	

   394 	}

   395 

   396 

   397 void CCodecDecodeTest::GotHeaders()

   398 	{

   399 	User::Invariant();	

   400 	}

   401 

   402 

   403 void CCodecDecodeTest::ParsingComplete(RMemChunk& /*aExcessData*/)

   404 	{

   405 	User::Invariant();	

   406 	}

   407 

   408 

   409 void CCodecDecodeTest::ParserError(TInt /*aError*/)

   410 	{

   411 	User::Invariant();	

   412 	}