--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/applayerprotocols/httptransportfw/Test/testhttpmessage/ctestmessagecomposer.cpp Tue Feb 02 01:09:52 2010 +0200
@@ -0,0 +1,443 @@
+// Copyright (c) 2003-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:
+// defines test classes: CTestMessageComposer
+//
+//
+#if !defined __CTESTMESSAGECOMPOSER_H__
+#include "ctestmessagecomposer.h"
+#endif
+
+_LIT8(KUri, "http://www.connecting.nokia.com");
+
+CTestMessageComposer* CTestMessageComposer::NewL(MTestObserver& aObserver)
+ {
+ CTestMessageComposer* self = new(ELeave) CTestMessageComposer(aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+CTestMessageComposer::~CTestMessageComposer()
+ {
+ iHeaders.Close();
+ iTransaction.Close();
+ iSession.Close();
+ iMessageComposer.Close();
+ Cancel();
+ }
+
+CTestMessageComposer::CTestMessageComposer(MTestObserver& aObserver)
+: CActive(CActive::EPriorityStandard), iObserver(aObserver)
+ {
+ CActiveScheduler::Add(this);
+ }
+
+void CTestMessageComposer::ConstructL()
+ {
+ iSession.OpenL();
+ iStringPool = iSession.StringPool();
+ iMessageComposer.OpenL(*this);
+ TUriParser8 up;
+ up.Parse(KUri);
+ iTransaction = iSession.OpenTransactionL(up, *this, iSession.StringPool().StringF(HTTP::EGET,RHTTPSession::GetTable()));
+ }
+
+void CTestMessageComposer::SetHeaderL(TInt aNumberofHeaders)
+ {
+ switch (aNumberofHeaders)
+ {
+ case 1:
+ {
+ // Open strings used in this test
+ //1.Accept header---- Accept: text/html; q=0.8, text/vnd.wap.wml; q=0.2; extended=value, text/*);
+ RStringF textHtml = iStringPool.StringF(HTTP::ETextHtml,RHTTPSession::GetTable());
+ RStringF textWml = iStringPool.StringF(HTTP::ETextVndWapWml,RHTTPSession::GetTable());
+ RStringF textAny = iStringPool.StringF(HTTP::ETextAny,RHTTPSession::GetTable());
+ RStringF extended = iStringPool.OpenFStringL(_L8("extended"));
+ CleanupClosePushL(extended);
+ RStringF extendVal = iStringPool.OpenFStringL(_L8("value"));
+ CleanupClosePushL(extendVal);
+ iHTTPHeaders = iTransaction.Request().GetHeaderCollection();
+ RStringF accept = iStringPool.StringF(HTTP::EAccept,RHTTPSession::GetTable());
+ THTTPHdrVal accVal(textHtml);
+ THTTPHdrVal q1(THTTPHdrVal::TQConv(0.8));
+ iHTTPHeaders.SetFieldL(accept, accVal, iStringPool.StringF(HTTP::EQ,RHTTPSession::GetTable()), q1);
+ accVal.SetStrF(textWml);
+ q1.SetInt(THTTPHdrVal::TQConv(0.2));
+ iHTTPHeaders.SetFieldL(accept, accVal, iStringPool.StringF(HTTP::EQ,RHTTPSession::GetTable()), q1);
+ q1.SetStrF(extendVal);
+ iHTTPHeaders.SetFieldL(accept, accVal, extended, q1);
+ accVal.SetStrF(textAny);
+ iHTTPHeaders.SetFieldL(accept, accVal);
+ CleanupStack::PopAndDestroy(2, &extended);
+
+ //2.Accept-Charset header-- Accept-Charset: iso-8859-5, unicode-1-1; q=0.8
+ RStringF iso8859_5 = iStringPool.OpenFStringL(_L8("iso-8859-5"));
+ CleanupClosePushL(iso8859_5);
+ RStringF unicode1_1 = iStringPool.OpenFStringL(_L8("unicode-1-1"));
+ CleanupClosePushL(unicode1_1);
+ RStringF accChSet= iStringPool.StringF(HTTP::EAcceptCharset,RHTTPSession::GetTable());
+ THTTPHdrVal accChSetVal(iso8859_5);
+ iHTTPHeaders.SetFieldL(accChSet, accChSetVal);
+ //
+ accChSetVal.SetStrF(unicode1_1);
+ THTTPHdrVal q2(THTTPHdrVal::TQConv(0.8));
+ iHTTPHeaders.SetFieldL(accChSet, accChSetVal, iStringPool.StringF(HTTP::EQ,RHTTPSession::GetTable()), q2);
+ CleanupStack::PopAndDestroy(2, &iso8859_5);
+
+ //3.User-Agent headers-- User-Agent: CERN-LineMode/2.15 libwww/2.17b3
+ // Open strings used in this test
+ RStringF ua1Str = iStringPool.OpenFStringL(_L8("CERN-LineMode/2.15"));
+ CleanupClosePushL(ua1Str);
+ RStringF ua2Str = iStringPool.OpenFStringL(_L8("libwww/2.17b3"));
+ CleanupClosePushL(ua2Str);
+ //
+ RStringF uaStr = iStringPool.StringF(HTTP::EUserAgent,RHTTPSession::GetTable());
+ THTTPHdrVal uaVal(ua1Str);
+ iHTTPHeaders.SetFieldL(uaStr, uaVal); // sets part 1
+ uaVal.SetStrF(ua2Str);
+ iHTTPHeaders.SetFieldL(uaStr, uaVal); // sets part 2
+ CleanupStack::PopAndDestroy(2,&ua1Str);
+
+ //4.Connection Header -- Connection: close, keep-alive
+ RStringF otherToken = iStringPool.StringF(HTTP::EKeepAlive,RHTTPSession::GetTable());
+ RStringF connStr = iStringPool.StringF(HTTP::EConnection,RHTTPSession::GetTable());
+ THTTPHdrVal connVal(iStringPool.StringF(HTTP::EClose,RHTTPSession::GetTable()));
+ iHTTPHeaders.SetFieldL(connStr, connVal); // sets part 1
+ THTTPHdrVal keepAlive(otherToken);
+ iHTTPHeaders.SetFieldL(connStr, keepAlive); // sets part 2
+
+ //5.content type header-- Content-Type: text/vnd.wap.wml; charset=utf-8; transcode=yes
+ RStringF textWml1 = iStringPool.StringF(HTTP::ETextVndWapWml,RHTTPSession::GetTable());
+ RStringF utf8 = iStringPool.OpenFStringL(_L8("utf-8"));
+ CleanupClosePushL(utf8);
+ RStringF extended1 = iStringPool.OpenFStringL(_L8("transcode"));
+ CleanupClosePushL(extended1);
+ RStringF extendVal1 = iStringPool.OpenFStringL(_L8("yes"));
+ CleanupClosePushL(extendVal1);
+ //
+ RStringF contType = iStringPool.StringF(HTTP::EContentType,RHTTPSession::GetTable());
+ THTTPHdrVal ctVal(textWml1);
+ THTTPHdrVal chSet(utf8);
+ iHTTPHeaders.SetFieldL(contType, ctVal, iStringPool.StringF(HTTP::ECharset,RHTTPSession::GetTable()), chSet);
+ chSet.SetStrF(extendVal1);
+ iHTTPHeaders.SetFieldL(contType, ctVal, extended1, chSet);
+ CleanupStack::PopAndDestroy(3,&utf8);
+
+ //6.host type header-- Host: nokia.com
+ RStringF host1Str = iStringPool.OpenFStringL(_L8("www.nokia.com"));
+ CleanupClosePushL(host1Str);
+ RStringF host = iStringPool.StringF(HTTP::EHost,RHTTPSession::GetTable());
+ THTTPHdrVal hostVal(host1Str);
+ iHTTPHeaders.SetFieldL(host, hostVal);
+ CleanupStack::PopAndDestroy(&host1Str);
+
+ //7.upgrade type header-- Upgrade: HTTP/2.0, SHTTP/1.3
+ RStringF http = iStringPool.OpenFStringL(_L8("HTTP/2.0"));
+ CleanupClosePushL(http);
+ RStringF shttp = iStringPool.OpenFStringL(_L8("SHTTP/1.3"));
+ CleanupClosePushL(shttp);
+ RStringF upgradeStr = iStringPool.StringF(HTTP::EUpgrade, RHTTPSession::GetTable());
+ THTTPHdrVal val(http);
+ THTTPHdrVal val2(shttp);
+
+ iHTTPHeaders.SetFieldL(upgradeStr, val);
+ iHTTPHeaders.SetFieldL(upgradeStr, val2);
+ CleanupStack::PopAndDestroy(2);
+
+ //8.Cache control -- Cache-Control: public, no-cache=\"wibble,wobble\"
+ _LIT8(KPublic, "public");
+ _LIT8(KNoCache, "no-cache=\"wibble,wobble\"");
+ RStringF publicStr = iStringPool.OpenFStringL(KPublic);
+ CleanupClosePushL(publicStr);
+ RStringF noCacheStr = iStringPool.OpenFStringL(KNoCache);
+ CleanupClosePushL(noCacheStr);
+ RStringF cc = iStringPool.StringF(HTTP::ECacheControl,RHTTPSession::GetTable());
+ iHTTPHeaders.SetFieldL(cc, THTTPHdrVal(publicStr));
+ iHTTPHeaders.SetFieldL(cc, THTTPHdrVal(noCacheStr));
+ CleanupStack::PopAndDestroy(2,&publicStr);
+
+ //9.Authorization-- Authorization: Basic c3ltYmlhbjpmMXN5bmNtbA==
+ RString basicCred = iStringPool.OpenStringL(_L8("c3ltYmlhbjpmMXN5bmNtbA=="));
+ CleanupClosePushL(basicCred);
+ RStringF authStr = iStringPool.StringF(HTTP::EAuthorization,RHTTPSession::GetTable());
+ THTTPHdrVal authVal(iStringPool.StringF(HTTP::EBasic,RHTTPSession::GetTable()));
+ iHTTPHeaders.SetFieldL(authStr, authVal); // sets part 1
+ THTTPHdrVal credVal(basicCred);
+ iHTTPHeaders.SetFieldL(authStr, credVal); // sets part 2
+ CleanupStack::PopAndDestroy(&basicCred);
+ break;
+ }
+
+ case 2:
+ {
+ //1. Connection: Keep-Alive\r\n
+ RStringF keep = iStringPool.StringF(HTTP::EKeepAlive,RHTTPSession::GetTable());
+ iHTTPHeaders = iTransaction.Request().GetHeaderCollection();
+ RStringF Connection= iStringPool.StringF(HTTP::EConnection,RHTTPSession::GetTable());
+ THTTPHdrVal keepalive(keep);
+ iHTTPHeaders.SetFieldL(Connection,keepalive);
+
+ //2.Host: 192.168.100.100\r\n
+ _LIT8(KHostIp, "192.168.100.100");
+ RStringF host2Str = iStringPool.OpenFStringL(KHostIp);
+ CleanupClosePushL(host2Str);
+ RStringF host2= iStringPool.StringF(HTTP::EHost,RHTTPSession::GetTable());
+ THTTPHdrVal hostip(host2Str);
+ iHTTPHeaders.SetFieldL(host2,hostip);
+ CleanupStack::PopAndDestroy(&host2Str);
+ //3.Accept: */*\r\n
+ _LIT8(KAccept2, "*/*");
+ RStringF acceptall = iStringPool.OpenFStringL(KAccept2);
+ CleanupClosePushL(acceptall);
+ RStringF accept2= iStringPool.StringF(HTTP::EAccept,RHTTPSession::GetTable());
+ THTTPHdrVal acceptvalue(acceptall);
+ iHTTPHeaders.SetFieldL(accept2,acceptvalue);
+ CleanupStack::PopAndDestroy(&acceptall);
+
+ //4.Accept-Charset: iso-8859-1,utf-8;q=0.7,*;q=0.7\r\n
+ RStringF iso8859 = iStringPool.OpenFStringL(_L8("iso-8859-1"));
+ CleanupClosePushL(iso8859);
+ RStringF utf8_1 = iStringPool.OpenFStringL(_L8("utf-8"));
+ CleanupClosePushL(utf8_1);
+ RStringF all = iStringPool.OpenFStringL(_L8("*"));
+ CleanupClosePushL(all);
+ RStringF accChSet1= iStringPool.StringF(HTTP::EAcceptCharset,RHTTPSession::GetTable());
+ THTTPHdrVal accChSetVal1(iso8859);
+ iHTTPHeaders.SetFieldL(accChSet1, accChSetVal1);
+ accChSetVal1.SetStrF(utf8_1);
+ THTTPHdrVal q3(THTTPHdrVal::TQConv(0.7));
+ iHTTPHeaders.SetFieldL(accChSet1, accChSetVal1, iStringPool.StringF(HTTP::EQ,RHTTPSession::GetTable()), q3);
+ accChSetVal1.SetStrF(all);
+ iHTTPHeaders.SetFieldL(accChSet1, accChSetVal1, iStringPool.StringF(HTTP::EQ,RHTTPSession::GetTable()), q3);
+ CleanupStack::PopAndDestroy(3,&iso8859);
+
+ //5.Accept-Encoding: gzip, deflate, x-gzip, identity; q=0.9\r\n
+ RStringF gzip = iStringPool.OpenFStringL(_L8("gzip"));
+ CleanupClosePushL(gzip);
+ RStringF deflate = iStringPool.OpenFStringL(_L8("deflate"));
+ CleanupClosePushL(deflate);
+ RStringF xgzip = iStringPool.OpenFStringL(_L8("x-gzip"));
+ CleanupClosePushL(xgzip);
+ RStringF identity = iStringPool.OpenFStringL(_L8("identity"));
+ CleanupClosePushL(identity);
+ RStringF acceptencoding1= iStringPool.StringF(HTTP::EAcceptEncoding,RHTTPSession::GetTable());
+ THTTPHdrVal aevalue(gzip);
+ iHTTPHeaders.SetFieldL(acceptencoding1, aevalue);
+ aevalue.SetStrF(deflate);
+ iHTTPHeaders.SetFieldL(acceptencoding1, aevalue);
+ aevalue.SetStrF(xgzip);
+ iHTTPHeaders.SetFieldL(acceptencoding1, aevalue);
+ aevalue.SetStrF(identity);
+ THTTPHdrVal q4(THTTPHdrVal::TQConv(0.9));
+ iHTTPHeaders.SetFieldL(acceptencoding1, aevalue, iStringPool.StringF(HTTP::EQ,RHTTPSession::GetTable()), q4);
+ CleanupStack::PopAndDestroy(4,&gzip);
+
+ //6.Accept-Language: en;q=1.0,bg;q=0.5,nl;q=0.5,fr;q=0.5\r\n
+ RStringF en = iStringPool.OpenFStringL(_L8("en"));
+ CleanupClosePushL(en);
+ RStringF bg = iStringPool.OpenFStringL(_L8("bg"));
+ CleanupClosePushL(bg);
+ RStringF nl = iStringPool.OpenFStringL(_L8("nl"));
+ CleanupClosePushL(nl);
+ RStringF fr = iStringPool.OpenFStringL(_L8("fr"));
+ CleanupClosePushL(fr);
+ RStringF acceptlanguage1= iStringPool.StringF(HTTP::EAcceptLanguage,RHTTPSession::GetTable());
+ THTTPHdrVal alvalue(en);
+ THTTPHdrVal q5(THTTPHdrVal::TQConv(1.0));
+ iHTTPHeaders.SetFieldL(acceptlanguage1, alvalue, iStringPool.StringF(HTTP::EQ,RHTTPSession::GetTable()), q5);
+ THTTPHdrVal q6(THTTPHdrVal::TQConv(0.5));
+ alvalue.SetStrF(bg);
+ iHTTPHeaders.SetFieldL(acceptlanguage1, alvalue, iStringPool.StringF(HTTP::EQ,RHTTPSession::GetTable()), q6);
+ alvalue.SetStrF(nl);
+ iHTTPHeaders.SetFieldL(acceptlanguage1, alvalue, iStringPool.StringF(HTTP::EQ,RHTTPSession::GetTable()), q6);
+ alvalue.SetStrF(fr);
+ iHTTPHeaders.SetFieldL(acceptlanguage1, alvalue, iStringPool.StringF(HTTP::EQ,RHTTPSession::GetTable()), q6);
+ CleanupStack::PopAndDestroy(4,&en);
+
+ //7.Referer: http://192.168.100.100/il/index.html\r\n
+ RStringF referer = iStringPool.OpenFStringL(_L8("http://192.168.100.100/il/index.html"));
+ CleanupClosePushL(referer);
+ RStringF refer= iStringPool.StringF(HTTP::EReferer,RHTTPSession::GetTable());
+ THTTPHdrVal referval(referer);
+ iHTTPHeaders.SetFieldL(refer,referval);
+ CleanupStack::PopAndDestroy(&referer);
+
+ //8.User-Agent: Mozilla/5.0 AppleWebKit/525
+ RStringF ua1Str1 = iStringPool.OpenFStringL(_L8("Mozilla/5.0"));
+ CleanupClosePushL(ua1Str1);
+ RStringF ua2Str2 = iStringPool.OpenFStringL(_L8("AppleWebKit/525"));
+ CleanupClosePushL(ua2Str2);
+ RStringF uaString = iStringPool.StringF(HTTP::EUserAgent,RHTTPSession::GetTable());
+ THTTPHdrVal uaVal1(ua1Str1);
+ iHTTPHeaders.SetFieldL(uaString, uaVal1); // sets part 1
+ uaVal1.SetStrF(ua2Str2);
+ iHTTPHeaders.SetFieldL(uaString, uaVal1); // sets part 2
+ CleanupStack::PopAndDestroy(2,&ua1Str1);
+ break;
+ }
+
+ default:
+ break;
+ }
+ }
+
+void CTestMessageComposer::StartRequest()
+ {
+ // Self-complete to kick-off the test.
+ CompleteSelf();
+ }
+
+void CTestMessageComposer::CompleteSelf()
+ {
+ TRequestStatus* pStat = &iStatus;
+ User::RequestComplete(pStat, KErrNone);
+ SetActive();
+ }
+
+void CTestMessageComposer::DoReset()
+ {
+ }
+
+/*
+ * Methods from CActive
+ */
+
+void CTestMessageComposer::RunL()
+ {
+ iHeaderIndex = 0;
+ iFlag = ETrue;
+ // Start the composer...
+ iMessageComposer.MessageInfoAvailable();
+ }
+
+void CTestMessageComposer::DoCancel()
+ {
+ // Do nothing...
+ }
+
+TInt CTestMessageComposer::RunError(TInt /*aError*/)
+ {
+ return KErrNone;
+ }
+
+/*
+ * Methods from MHttpMessageComposerObserver
+ */
+
+void CTestMessageComposer::StartLineL(TPtrC8& aMethod, TPtrC8& aRequestUri, TPtrC8& aVersion)
+ {
+ // The RFC2616 defines the Request-Line as follows -
+ //
+ // Request-Line = Method SP Request-URI SP HTTPVersion CRLF
+ //
+ // Get Method...
+ iRequest = iTransaction.Request();
+ RStringF method = iStringPool.StringF(iRequest.Method());
+ aMethod.Set(method.DesC());
+
+ // Get the Request-URI...
+ aRequestUri.Set(KUri);
+
+ // Assume HTTP/1.1
+ aVersion.Set(iStringPool.StringF(HTTP::EHttp11, RHTTPSession::GetTable()).DesC());
+ }
+
+TInt CTestMessageComposer::NextHeaderL(TPtrC8& aHeaderName, TPtrC8& aHeaderValue)
+ {
+ if(iFlag)
+ {
+ THTTPHdrFieldIter it = iHTTPHeaders.Fields();
+ iFlag = EFalse;
+ while(!it.AtEnd())
+ {
+ // Get field current field.
+ RStringF name = iStringPool.StringF(it());
+ CleanupClosePushL(name);
+ // Get the OTA version of the field value
+ TPtrC8 value;
+ iRequest.GetHeaderCollection().GetRawField(name, value);
+ User::LeaveIfError(iHeaders.Append(THeaderField(name.DesC(), value)));
+ // Move onto next header field...
+ ++it;
+ CleanupStack::PopAndDestroy(&name);
+ }
+ }
+ TInt error = ( iHeaderIndex < iHeaders.Count() ) ? KErrNone : KErrNotFound;
+ if( iHeaderIndex < iHeaders.Count() )
+ {
+ // Give the current header info...
+ THeaderField header = iHeaders[iHeaderIndex];
+
+ aHeaderName.Set(header.iName);
+ aHeaderValue.Set(header.iValue);
+
+ // Loop to next header...
+ ++iHeaderIndex;
+ }
+ else
+ {
+ // No more headers - change state
+ iState = EPendingHasBody;
+ }
+ return error;
+ }
+
+
+
+TInt CTestMessageComposer::NextTrailerL(TPtrC8& /*aHeaderName*/, TPtrC8& /*aHeaderValue*/)
+ {
+ return KErrNotFound;
+ }
+
+void CTestMessageComposer::MessageComplete()
+ {
+ iState = EDone;
+ iObserver.NotifyComplete();
+ }
+
+void CTestMessageComposer::MessageDataReadyL()
+ {
+ // // Get data from the composer
+ TPtrC8 data;
+ iMessageComposer.GetMessageData(data);
+ iMessageComposer.ReleaseMessageData();
+ }
+
+TInt CTestMessageComposer::HandleComposeError(TInt /*aError*/)
+ {
+ return KErrNone;
+ }
+
+MHTTPDataSupplier* CTestMessageComposer::HasBodyL()
+ {
+ iState = EPendingMessageComplete;
+ return NULL;
+ }
+
+void CTestMessageComposer::Reserved_MHttpMessageComposerObserver()
+ {
+ User::Invariant();
+ }
+
+TInt CTestMessageComposer::MHFRunError(TInt /*aError*/, RHTTPTransaction /*aTransaction*/, const THTTPEvent& /*aEvent*/)
+ {
+ return KErrNone;
+ }
+
+void CTestMessageComposer::MHFRunL(RHTTPTransaction /*aTransaction*/, const THTTPEvent& /*aEvent*/)
+ {
+ }
+