diff -r 000000000000 -r f5a58ecadc66 servicediscoveryandcontrol/pnp/test/integtest/src/testpnpmanager.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/servicediscoveryandcontrol/pnp/test/integtest/src/testpnpmanager.cpp	Tue Feb 02 01:12:20 2010 +0200
@@ -0,0 +1,829 @@
+// Copyright (c) 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:
+// Contains implementation of CTestPnPManager class
+// Contains implemenatation of CTestPnPManager, CTestPnPObserver, CTestPnPTimer, 
+// and CAction classes
+// 
+//
+
+#include "testpnpmanager.h"
+
+
+/*
+  Constructor:
+  @test
+*/
+CTestPnPManager::CTestPnPManager()
+:	CTestStep()
+	{
+	iCancelDiscovery = EFalse;
+	}
+
+/*
+   Initializes all member vaiables.
+   @param		None.
+   @return		None.
+*/
+void CTestPnPManager::InitializeL()
+	{
+    iScheduler = new (ELeave) CActiveScheduler;
+	CActiveScheduler::Install(iScheduler);
+	}
+
+/*
+   Destructor
+   @test
+*/
+CTestPnPManager::~CTestPnPManager()
+	{
+	_LIT(KInfoDesctructorBegin, "Begin: In Destructor CTestPnPanager....\n");
+	INFO_PRINTF1(KInfoDesctructorBegin);
+	delete iScheduler;
+	iScheduler = NULL;	
+	iControlChannel.Close();	
+	iControlPoint.Close();
+	iServicePoint.Close();
+	}
+
+
+
+/*
+   Implementation of CTestStep base class virtual and this is used for doing all
+   initialisation common
+    to derived classes here.
+   @param  None
+   @return TVerdict
+ */
+TVerdict CTestPnPManager::doTestStepPreambleL()
+	{
+    InitializeL();
+	return CTestStep::doTestStepPreambleL();
+	}
+
+
+/*
+ return Script File name..if any
+*/
+const TDesC& CTestPnPManager::ScriptFileName()
+	{
+	return iScriptName;
+	}
+
+
+/*
+   Implementation of CTestStep base class virtual and it is used for doing all
+   after test treatment common to derived classes in here.
+   @return TVerdict
+ */
+TVerdict CTestPnPManager::doTestStepPostambleL()
+	{
+	return CTestStep::doTestStepPostambleL();
+	}
+
+
+TVerdict CTestPnPManager::doTestStepL()
+	{
+	SequenceOperationsL();
+	return TestStepResult();
+	}
+
+/*
+   This function performs operations based on sequence specified in the ini file
+   @param  None
+   @return None
+*/
+void CTestPnPManager::SequenceOperationsL()
+	{
+	_LIT(KInfoLogFile, "SequenceOperationsL().... \n");
+	INFO_PRINTF1(KInfoLogFile);
+	RArray<TPtrC> sequenceList;
+	CleanupClosePushL(sequenceList);
+	TPtrC listOfSequences;
+	_LIT(KListOfSequences, "listofsequences");
+	GetStringFromConfig(ConfigSection(), KListOfSequences, listOfSequences);
+
+	TokenizeStringL(listOfSequences, sequenceList);
+	TInt numOperations = sequenceList.Count();
+
+	for(TInt i(0); i < numOperations; i++)
+		{
+		SetCurrentSection(sequenceList[i]);
+		PerformDesiredOperationsL(sequenceList[i]);
+		}
+	CleanupStack::PopAndDestroy(); 
+	_LIT(KInfoLogFile1, "SequenceOperationsL() End.... \n");
+	INFO_PRINTF1(KInfoLogFile1);
+	}
+
+
+/*
+   This function performs desired operations specified as a parameter
+   @param  aOperation string representing operation to be performed
+   @return None
+*/
+void CTestPnPManager::PerformDesiredOperationsL(const TDesC& aOperation)
+	{
+	const TInt KMatch = 0;
+	TPtrC operationType;
+	_LIT(KOperationType, "operationtype");
+	GetStringFromConfig(aOperation, KOperationType, operationType);
+	
+	if(operationType.Compare(KOpenDiscoverer) == KMatch)
+		{
+		OpenDiscovererL();
+		}
+	else if(operationType.Compare(KOpenPublisher) == KMatch)
+		{
+		OpenPublisherL();
+		}
+	else if(operationType.Compare(KDiscovery) == KMatch)
+		{
+		DiscoverL();
+		}
+	else if(operationType.Compare(KCancelDiscover) == KMatch)
+		{
+		CancelDiscoverL();
+		}
+	else if(operationType.Compare(KDescribe) == 0)
+	    {
+    	DescribeServiceL();
+    	}
+    else if(operationType.Compare(KCancelDescribe) == KMatch)
+		{
+		CancelDescribeL();
+		}
+	else if(operationType.Compare(KPublishService) == KMatch)
+		{
+		PublishServiceL(aOperation);
+		}
+	else if(operationType.Compare(KSubscribe) == KMatch)
+		{
+		SubscribeForStateChangeNotificationsL();
+		}
+	else if(operationType.Compare(KRegisterAnnouncement) == KMatch)
+		{
+		RegisterForAnnouncementsL();
+		}
+	else if(operationType.Compare(KCancelNotify) == KMatch)
+		{
+		CancelNotifyAnnouncementL();
+		}
+	else if(operationType.Compare(KNotify) == KMatch)
+		{
+	    SendNotificationsL();
+		}
+	else if(operationType.Compare(KOpenDiscovererFail) == KMatch)
+	   {
+	   OpenDiscovererFailed();
+	   }
+    else if(operationType.Compare(KOpenPublisherFail) == KMatch)
+	   {
+	   OpenPublisherFailed();   
+	   }
+	}
+
+/*
+   Parses a comma separated string and constructs a list out of the values
+   @param	aString a reference to a string to be tokenized
+   @param	aList is an out parameter to store a list of tokens in an arry
+   @param	aSeparator is a character used to delimit the tokens
+  */
+void CTestPnPManager::TokenizeStringL(const TDesC& aString, RArray<TPtrC>& aList, TChar aSeparator)
+	{
+	TLex lexer(aString);
+
+	while(!lexer.Eos())
+		{
+		lexer.SkipSpaceAndMark();
+
+		while(!lexer.Eos() && lexer.Get() != aSeparator)
+			{
+			}
+
+		if(!lexer.Eos())
+			{
+			lexer.UnGet();
+			}
+		aList.AppendL(lexer.MarkedToken());
+		lexer.Inc();
+		}
+	}
+
+
+/*
+   Sets the current config section.
+   @param	aCurrentSection - a reference string that represent current config section
+   @return	None
+ */
+void CTestPnPManager::SetCurrentSection(const TDesC& aCurrentSection)
+	{
+	iCurrentSection = aCurrentSection;
+	}
+
+/*
+   Retrieve the current config section.
+   @param
+   @return	Reference to current config section
+ */
+TDesC& CTestPnPManager::GetCurrentSection()
+	{
+	return	iCurrentSection;
+	}
+
+/*
+	Tests whether discovering services/devices is performed
+	@param		aOperationType is reference to a section name in ini file where required parameters
+				needs to be referred for this operation.
+	@return		None.
+ */
+void CTestPnPManager::DiscoverL()
+	{
+	RArray<TPtrC> serviceTypeList;
+	TPtrC listOfServiceTypes;
+	_LIT(KListOfServiceTypes, "listofservicetypes");
+	_LIT(KInfoLogFile, "DiscoverL.... \n");
+	INFO_PRINTF1(KInfoLogFile);
+	CTestPnPObserver* pnpObserver = CTestPnPObserver::NewL(this);
+	
+	RPnPParameterBundle pnpBundle;
+	pnpBundle.Open ();
+	CleanupClosePushL( pnpBundle );
+	pnpBundle.SetPnPObserver((MPnPObserver*)pnpObserver);
+
+	RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (ETestPnPDiscoverRequestParamSet);
+	if(!GetStringFromConfig(GetCurrentSection(), KListOfServiceTypes, listOfServiceTypes))
+		{
+		_LIT(KErrInfo, "Problem in reading values from ini. \n Expected fields are: \n%S \n");
+		ERR_PRINTF2( KErrInfo, &KListOfServiceTypes );
+		return;
+		}
+
+	TokenizeStringL(listOfServiceTypes, serviceTypeList);
+	TInt numUris = serviceTypeList.Count();
+
+	serviceTypeList.Close();
+	iControlPoint.Discover(pnpBundle);
+
+	_LIT(KInfoLogFile1, "DiscoverL End... \n");
+	INFO_PRINTF1(KInfoLogFile1);
+	CleanupStack::PopAndDestroy( &pnpBundle );
+	}
+
+
+/*
+	Tests whether Publishing a Service/Device is performed
+	@param			aOperationType is reference to a section name in ini file where required parameters
+					needs to be referred for this operation.
+	@return			None.
+ */
+void CTestPnPManager::PublishServiceL (const TDesC& aOperationType)
+	{
+	_LIT(KInfoLogFile, "PublishServiceL().... \n");
+	INFO_PRINTF1(KInfoLogFile);
+	CTestPnPObserver* pnpObserver = CTestPnPObserver::NewL(this);
+	RPnPParameterBundle pnpBundle ;
+	pnpBundle.Open();
+	
+    CleanupClosePushL( pnpBundle );
+    pnpBundle.SetPnPObserver((MPnPObserver*)pnpObserver);
+    RParameterFamily family = pnpBundle.CreateFamilyL(ETestPnPServiceRegisterParamSet);
+    
+    TPtrC serviceType;
+	GetStringFromConfig(aOperationType, KServiceType, serviceType);
+	RBuf8 serviceTypeBuf;
+	serviceTypeBuf.Create(serviceType.Length());
+	serviceTypeBuf.Copy(serviceType);
+	
+	iServicePoint.Publish( pnpBundle );
+    serviceTypeBuf.Close();
+    
+	_LIT(KInfoLogFile1, "PublishServiceL() End.... \n");
+	INFO_PRINTF1(KInfoLogFile1);
+	CleanupStack::PopAndDestroy( &pnpBundle );
+	}
+
+
+void CTestPnPManager::SendNotificationsL ()
+	{
+	_LIT(KInfoLogFile, "SendNotificationsL.... \n");
+	INFO_PRINTF1(KInfoLogFile);
+ 
+    RPnPParameterBundle pnpBundle;
+    pnpBundle.CreateL();   
+    CleanupClosePushL( pnpBundle );
+
+	RParameterFamily pnpFamily = pnpBundle.CreateFamilyL(ETestPnPServiceNotificationParamSet);
+
+	iServicePoint.SendNotify( pnpBundle );
+    _LIT(KInfoLogFile1, "SendNotificationsL End.... \n");
+	INFO_PRINTF1(KInfoLogFile1);
+	CleanupStack::Pop( &pnpBundle );	
+	}
+
+
+/*	Opens a handle to a RPnPServiceDiscovery object
+	@param			None.
+	@return			None.
+ */
+void CTestPnPManager::OpenDiscovererL()
+	{
+	_LIT(KInfoLogFile, "OpenDiscovererL().... \n");
+	INFO_PRINTF1(KInfoLogFile);
+	
+	TBool cpStatus = EFalse;
+	TInt openStatus = 0;
+	_LIT(KCpStatus, "cpstatus");
+	GetBoolFromConfig(GetCurrentSection(), KCpStatus, cpStatus);
+	if(!cpStatus)
+		{
+		_LIT(KInfoDiscoverer, "Control Point should not be Created \n");
+		INFO_PRINTF1(KInfoDiscoverer);
+		return;
+		}
+
+	openStatus = iControlPoint.Open(KTestTierId);
+	
+	if(openStatus != KErrNone) 
+		{
+		_LIT(KOpenDiscovererFailed, "Control Point discovery open failed with error %d ");
+		ERR_PRINTF2(KOpenDiscovererFailed, openStatus);
+		SetTestStepError(openStatus);
+		}
+	else
+		{
+		_LIT(KOpenDiscovererSuccess, "Control Point Discovery was successfully started with return value %d :");
+		INFO_PRINTF2(KOpenDiscovererSuccess, openStatus);
+		}
+		
+	_LIT8(KUri, "Prakash");
+	TBuf8<255> buf(KUri);
+	iControlPoint.InitiateControl(iControlChannel,buf);
+	iMsg.SetMessagePtr(buf);
+    TPtrC8 iPtr=iMsg.MessagePtr();	
+    if ( !iMsg.IsLast () )
+	      {
+	      iMsg.ClearFlags();
+	      iControlChannel.Send(iMsg,iStatus);
+	      CTestTimer* testTimer = CTestTimer::NewL(*this);
+	      testTimer->After(2000000);
+	      CActiveScheduler::Start();
+	      delete testTimer;
+		  }
+	}
+
+
+/*
+	Opens a handle to a RPnPServicePublisher object 
+	@param			None.
+	@return			TBool representing success or failure of the operation.
+ */
+void CTestPnPManager::OpenPublisherL()
+	{
+	_LIT(KInfoLogFile, "OpenPublisherL().... \n");
+	INFO_PRINTF1(KInfoLogFile);
+	
+	TBool spStatus = EFalse;
+	TInt openStatus = 0;
+	_LIT(KSpStatus, "spstatus");
+	GetBoolFromConfig(GetCurrentSection(), KSpStatus, spStatus);
+
+	openStatus = iServicePoint.Open(KTestTierId);
+
+  	if( openStatus != KErrNone )
+  		{
+ 		_LIT(KOpenDiscovererFailed, "Publisher open failed with error %d ");
+ 		ERR_PRINTF2(KOpenDiscovererFailed, openStatus);
+ 		SetTestStepError(openStatus);
+ 		}
+ 	else
+ 		{
+ 		_LIT(KOpenPublisherSuccess, "Service publisher was successfully started with return value %d :");
+  		INFO_PRINTF2(KOpenPublisherSuccess, openStatus);
+ 		}
+ 		
+ 	iServicePoint.InitiateControl(iControlChannel);
+	_LIT8(KUri, "Rajesh");
+	TBufC8<255> buf(KUri);	
+	iMsg.SetMessageDes ( buf );    
+    iMsg.SetLast ();
+    TPtrC8 iPtr= iMsg.MessageDes();
+	TInt newLen = buf.Length();
+	iMsg.SetMaxLength (newLen);
+	TInt maxLen =iMsg.MaxLength();
+	iControlChannel.Recv(iMsg,iStatus);
+    CTestTimer* testTimer = CTestTimer::NewL(*this);
+	testTimer->After(2000000);
+	CActiveScheduler::Start();
+	delete testTimer;
+	}
+	
+
+/*
+Test for Register announcements ssdp:alive and ssdp:byebye messages
+	@param			aOperationType is reference to a section name in ini file where required parameters
+					needs to be referred for this operation.
+	@return			None.
+*/
+void  CTestPnPManager::RegisterForAnnouncementsL ()
+	{
+	_LIT(KInfoLogFile, "RegisterForAnnouncementsL().... \n");
+	INFO_PRINTF1(KInfoLogFile);
+	RArray<TPtrC> uriTypeList;
+	TPtrC listOfUriTypes;
+	_LIT(KListOfUriTypes, "listofuritypes");
+	CTestPnPObserver* pnpObserver = CTestPnPObserver::NewL(this);
+	
+	RPnPParameterBundle pnpBundle;
+	pnpBundle.CreateL ();
+	CleanupClosePushL( pnpBundle );
+	pnpBundle.SetPnPObserver((MPnPObserver*)pnpObserver);
+	RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (ETestPnPRegisterAnnouncementParamSet);
+	
+	if(!GetStringFromConfig(GetCurrentSection(), KListOfUriTypes, listOfUriTypes))
+		{
+		_LIT(KErrInfo, "Problem in reading values from ini. \n Expected fields are: %S \n");
+		ERR_PRINTF2( KErrInfo, &KListOfUriTypes);
+		return;
+		}
+
+	TokenizeStringL(listOfUriTypes, uriTypeList);
+	TInt numUris = uriTypeList.Count();
+
+	uriTypeList.Close();
+	iControlPoint.RegisterNotify( pnpBundle );
+	CleanupStack::PopAndDestroy( &pnpBundle );
+	_LIT(KInfoLogFile1, "RegisterForAnnouncementsL() End.... \n");
+	INFO_PRINTF1(KInfoLogFile1);	
+	}
+
+/*
+	Tests whether subscribtion to event change notifications is performed
+	@param			None.
+	@return			None.
+ */
+void  CTestPnPManager::SubscribeForStateChangeNotificationsL()
+	{
+	_LIT(KInfoLogFile, "SubscribeForStateChangeNotificationsL() start.... \n");
+	INFO_PRINTF1(KInfoLogFile);
+	CTestPnPObserver* pnpObserver = CTestPnPObserver::NewL(this);
+	CleanupStack::PushL( pnpObserver );
+	RPnPParameterBundle pnpBundle;
+	pnpBundle.CreateL ();
+	CleanupClosePushL( pnpBundle );
+	pnpBundle.SetPnPObserver((MPnPObserver*)pnpObserver);
+	RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (ETestPnPSubscribeRequestParamSet);
+
+	iControlPoint.Subscribe( pnpBundle );
+	CleanupStack::PopAndDestroy( &pnpBundle );
+	CleanupStack::PopAndDestroy( pnpObserver );
+	_LIT(KInfoLogFile1, "SubscribeForStateChangeNotificationsL() End.... \n");
+	INFO_PRINTF1(KInfoLogFile1);
+	}
+
+
+/*	Test for Cancelling Discovery Operation
+	@param			aOperationType is reference to a section name in ini file where required parameters
+					needs to be referred for this operation.
+	@return			None.
+*/
+void CTestPnPManager::CancelDiscoverL()
+	{
+	iCancelDiscovery = ETrue;
+	_LIT(KInfoLogFile, "CancelDiscoverL().... \n");
+	INFO_PRINTF1(KInfoLogFile);
+	
+	CTestPnPObserver* pnpObserver = CTestPnPObserver::NewL(this);
+	
+	RPnPParameterBundle pnpBundle;
+	pnpBundle.CreateL ();
+	CleanupClosePushL( pnpBundle );
+	pnpBundle.SetPnPObserver((MPnPObserver*)pnpObserver);
+
+	RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (ETestPnPCancelDiscoverParamSet);
+
+	iControlPoint.Cancel ( pnpBundle );
+	CleanupStack::PopAndDestroy( &pnpBundle );
+	
+	_LIT(KInfoLogFile1, "CancelDiscoverL() End.... \n");
+	INFO_PRINTF1(KInfoLogFile1);
+	}
+
+void CTestPnPManager::CancelDescribeL()
+	{
+	_LIT(KInfoLogFile, "CancelDescribeL().... \n");
+	INFO_PRINTF1(KInfoLogFile);
+	CTestPnPObserver* pnpObserver = CTestPnPObserver::NewL(this);
+	
+	RPnPParameterBundle pnpBundle;
+	pnpBundle.CreateL ();
+	CleanupClosePushL( pnpBundle );
+	pnpBundle.SetPnPObserver((MPnPObserver*)pnpObserver);
+
+	RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (ETestPnPCancelDescribeParamSet);
+
+	iControlPoint.Cancel ( pnpBundle );
+	CleanupStack::PopAndDestroy( &pnpBundle );
+	_LIT(KInfoLogFile1, "CancelDescribeL() End.... \n");
+	INFO_PRINTF1(KInfoLogFile1);
+	}
+
+
+
+/*	Test for Cancelling Register Announcement
+	@param			aOperationType is reference to a section name in ini file where required parameters
+					needs to be referred for this operation.
+	@return			None.
+ */
+void  CTestPnPManager::CancelNotifyAnnouncementL()
+	{
+	_LIT(KInfoLogFile, "CancelNotifyAnnouncementL().... \n");
+	INFO_PRINTF1(KInfoLogFile);
+	CTestPnPObserver* pnpObserver = CTestPnPObserver::NewL(this);
+		
+	RPnPParameterBundle pnpBundle;
+	pnpBundle.CreateL ();
+	CleanupClosePushL( pnpBundle );
+	pnpBundle.SetPnPObserver((MPnPObserver*)pnpObserver);
+	RParameterFamily pnpFamily = pnpBundle.CreateFamilyL ( ETestPnPCancelRegisterNotifyParamSet );
+	
+	iControlPoint.Cancel ( pnpBundle);
+	CleanupStack::PopAndDestroy( &pnpBundle );
+	_LIT(KInfoLogFile1, "CancelNotifyAnnouncementL() End.... \n");
+	INFO_PRINTF1(KInfoLogFile1);
+	}
+
+/*
+  Constructor:
+*/
+CTestPnPObserver::CTestPnPObserver()
+	:iSequence(0)
+	{
+	}
+
+/*
+  Destructor
+*/
+CTestPnPObserver::~CTestPnPObserver()
+	{
+	}
+
+
+/*
+	Static factory constructor. Uses two phase construction and leaves nothing on the
+	CleanupStack. Creates a CTestControlPointService object.
+	@param			aManager	A pointer to a CTestPnPManager object.
+	@return			A pointer to the newly created CPnPObserver object.
+	@post			A fully constructed and initialized CPnPObserver object.
+ */
+CTestPnPObserver* CTestPnPObserver::NewL(CTestPnPManager* aManager)
+	{
+	CTestPnPObserver* self = new(ELeave) CTestPnPObserver;
+	CleanupStack::PushL(self);
+	self->ConstructL(aManager);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+/*
+	Second phase of two-phase construction method. Does any allocations required to fully construct
+	the object.
+	@pre 		First phase of construction is complete.
+	@param		aManager	A pointer to a CTestPnPManager object.
+	@post		The object is fully constructed and initialized.
+ */
+void CTestPnPObserver::ConstructL(CTestPnPManager* aManager)
+	{
+	iManager = aManager;
+	}
+
+
+
+/*
+   This method returns a reference to the CTestPnPManager object.
+   @param None
+   return a reference to the CTestPnPManager object
+ */
+CTestPnPManager& CTestPnPObserver::Manager()
+	{
+	return *iManager;
+	}
+
+/*
+   This is called when callback hits. And this method stores the bundle results
+   and meta information related to that results into results array maintained by manager
+   for later verification.
+   @param  aParameterBundle a reference to CPnPParameterBundleBase
+   @return None
+ */
+void CTestPnPObserver::OnPnPEventL ( RPnPParameterBundleBase& aParameterBundle)
+	{
+	_LIT(KInfoLogFile, "OnPnPEventL ().... \n");
+	Manager().INFO_PRINTF1(KInfoLogFile);
+
+	RParameterFamily paramFamily = aParameterBundle.GetFamilyAtIndex(0);
+	
+	if( paramFamily.IsNull ())
+		{
+		switch ( paramFamily.Id() )
+			{
+			case ETestPnPDiscoverResponseParamSet:
+				{				
+				_LIT(KInfoLogFile, "Discovery Response\n \n");
+	            Manager().INFO_PRINTF1(KInfoLogFile);
+				}
+			break;
+			
+			case ETestPnPPresenceAnnouncementParamSet:
+				{
+				_LIT(KInfoLogFile, "Presence Announcement Response\n");
+	            Manager().INFO_PRINTF1(KInfoLogFile);
+				}
+			break;
+
+			case ETestPnPAbsenceAnnouncementParamSet:
+				{				
+				_LIT(KInfoLogFile, "Absence Announcement Response\n");
+	            Manager().INFO_PRINTF1(KInfoLogFile);
+				}
+			break;
+
+			case ETestPnPPublishResponseParamSet:
+				{
+                _LIT(KInfoLogFile, "Publish Response\n");
+	            Manager().INFO_PRINTF1(KInfoLogFile);
+				}
+			break;
+			
+			case ETestPnPDescribeResponseParamSet:
+				{							
+				_LIT(KInfoLogFile, "Describe Response\n");
+	            Manager().INFO_PRINTF1(KInfoLogFile);
+			    }
+			break;
+			
+			case ETestPnPSubscribeResponseParamSet:
+				{				
+                _LIT(KInfoLogFile, "Subscribe Response\n");
+	            Manager().INFO_PRINTF1(KInfoLogFile);
+             	}
+			break;
+			
+			case ETestPnPNotifyEventParamSet:
+				{//receives event notifications sent at client
+				_LIT(KInfoLogFile, "Notify Event Response\n");
+	            Manager().INFO_PRINTF1(KInfoLogFile);
+				}
+			break;
+			
+			default:
+			break;
+			}
+		}
+	}
+
+/*
+   Error handling,asynchronous one.
+   @param  aError Error Code
+   @return None
+ */
+void CTestPnPObserver::OnPnPError(TInt aError)
+	{
+	_LIT(KPositiveCase,"positivecase");
+	TBool positiveCase = ETrue;
+	Manager().GetBoolFromConfig(Manager().GetCurrentSection(), KPositiveCase, positiveCase);
+	// Note down the error and stop scheduler
+	_LIT(KErrorMessage, "Error occurred in the Test PnP Observer : %d \n");
+	Manager().ERR_PRINTF2(KErrorMessage, aError);
+	}
+
+
+void CTestPnPManager::DescribeServiceL()
+	{
+	_LIT(KInfoLogFile, "CTestPnPManager::DescribeServiceL().... \n");
+	INFO_PRINTF1(KInfoLogFile);
+
+	CTestPnPObserver* pnpObserver = CTestPnPObserver::NewL(this);
+	CleanupStack::PushL( pnpObserver );	
+	
+	RPnPParameterBundle pnpBundle;
+	pnpBundle.Open ();
+	CleanupClosePushL( pnpBundle );
+	pnpBundle.SetPnPObserver((MPnPObserver*)pnpObserver);
+
+	RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (ETestPnPDescribeRequestParamSet);	
+
+	iControlPoint.Describe( pnpBundle );
+	_LIT(KInfoLogFile1, "CTestPnPManager::DescribeServiceL() End.... \n");
+	INFO_PRINTF1(KInfoLogFile1);
+	
+	CleanupStack::PopAndDestroy( &pnpBundle );
+	CleanupStack::PopAndDestroy( pnpObserver );
+	}
+
+
+/*Fails to open a handle to a RPnPServiceDiscovery object
+  @param			None.
+  @return			None.
+ */
+void CTestPnPManager::OpenDiscovererFailed()
+	{
+	_LIT(KInfoLogFile, "OpenDiscovererFailed().... \n");
+	INFO_PRINTF1(KInfoLogFile);
+	
+	TInt openStatus = 0;
+	openStatus = iControlPoint.Open(KInvalidTestTierId);
+	
+	if(openStatus != KErrNone) 
+		{
+		_LIT(KOpenDiscovererFailed, "Control Point discovery open failed with error %d ");
+		ERR_PRINTF2(KOpenDiscovererFailed, openStatus);
+		SetTestStepError(openStatus);
+		}
+	else
+		{
+		_LIT(KOpenDiscovererSuccess, "Control Point Discovery was successfully started with return value %d :");
+		INFO_PRINTF2(KOpenDiscovererSuccess, openStatus);
+		}
+	}
+	
+	
+/*Fails to open a handle to a RPnPServicePublisher object
+  @param			None.
+  @return			None.
+ */
+void CTestPnPManager::OpenPublisherFailed()
+	{
+	_LIT(KInfoLogFile, "OpenPublisherFailed().... \n");
+	INFO_PRINTF1(KInfoLogFile);
+	
+	TInt openStatus = 0;	
+	openStatus = iServicePoint.Open(KInvalidTestTierId);
+		
+	if( openStatus != KErrNone )
+  		{
+ 		_LIT(KOpenPublisherFailed, "Publisher open failed with error %d ");
+ 		ERR_PRINTF2(KOpenPublisherFailed, openStatus);
+ 		SetTestStepError(openStatus);
+ 		}
+ 	else
+ 		{
+ 		_LIT(KOpenPublisherSuccess, "Service publisher was successfully started with return value %d :");
+  		INFO_PRINTF2(KOpenPublisherSuccess, openStatus);
+ 		}
+	}
+	
+void CTestPnPManager::TimedOut()
+	{
+	iControlChannel.CancelRecv();
+	iControlChannel.CancelSend();
+	CActiveScheduler::Stop();	
+	}
+	
+// CTestTimer //
+CTestTimer* CTestTimer::NewL(MTimerObserver& aObserver)
+	{
+	return new(ELeave) CTestTimer(aObserver);	
+	}
+
+CTestTimer::~CTestTimer()
+	{
+	Cancel();
+	iTimer.Close();
+	}
+
+CTestTimer::CTestTimer(MTimerObserver& aObserver)
+:CActive(EPriorityStandard), iObserver(aObserver)
+	{
+	CActiveScheduler::Add(this);
+	iTimer.CreateLocal();
+	}
+
+void CTestTimer::RunL()
+	{
+	iObserver.TimedOut();
+	}
+
+void CTestTimer::DoCancel()
+	{
+	iTimer.Cancel();	
+	}
+	
+void CTestTimer::After(TTimeIntervalMicroSeconds32 aInterval)
+	{
+	iTimer.After(iStatus,  aInterval);
+	SetActive();
+	}
+	
+	
+