// Copyright (c) 2007-2010 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:

// EFM test steps for component testing

// 

//

/**

 @file

 @internalComponent

 @test

*/

#include <featmgr/featurecontrol.h>

#include <featmgr/featmgr.h>

#include <featdiscovery.h>

#include "component_test_steps.h"

#include <apgcli.h>

#include <apacmdln.h>

#define THREADS 100

void CNotifierObserver::HandleNotifyChange( TFeatureChangeType, TFeatureEntry )

	{

	CActiveScheduler::Stop();

	}

void CNotifierObserver::HandleNotifyError( TInt )

	{

	}

CFeatMgrStressTest::CFeatMgrStressTest()

   {

   SetTestStepName( KFeatMgrStressTest );

   }

CFeatMgrStressTest::~CFeatMgrStressTest()

	{	

	//Wait for a second to let test threads die naturally before trying to 

	//kill them.  If the threads are forcefully killed there can be issues

	//closing iThreadsArr

	User::After(1000000);

	// Killing each created thread 

    for ( TInt  i=0; i<iThreadsArr.Count(); ++i)

         {

         iThreadsArr[i].Kill(1);

         }

    // Closing the array of threads

    iThreadsArr.Close();

    // Closing the critical section

    iSection.Close();

	}

TVerdict CFeatMgrStressTest::doTestStepL()

	{

	User::LeaveIfError(iSection.CreateLocal());

	for(TInt i=0; i<THREADS; i++)

		{	

		TBuf<10> threadName;

		threadName.Format(_L("Thread%d"), i);

		RThread thread;

		TInt err = thread.Create(threadName, CFeatMgrStressTest::ThreadeEntryPoint, KDefaultStackSize, NULL, this);

		if( KErrNone != err )

			{

			User::Panic(_L("Thread could not be created"), err);

			}

		else

			{

			User::LeaveIfError(iThreadsArr.Append(thread));

			iThreadsArr[i].Resume();

			}

		}

	// To keep the main thread which created the other threads alive untill the test finishes

	RSemaphore semaphore;

	User::LeaveIfError(semaphore.CreateGlobal(_L("ThreadsSemaphore"), 0));

	semaphore.Wait();

	TBuf<500> temp;

	_LIT(KPostfix, "; ");

	for( TInt i=0; i<iThreadsInfoArr.Count(); ++i )

		{

		TBool testfailed = EFalse;

		temp.Format(_L("Thread id = %d:  "), iThreadsInfoArr[i].iId);

		if( KErrNone != iThreadsInfoArr[i].iStartServerErr )

			{

			temp.Append(_L("RFeatureControl::Open expects KErrNone, error value: "));

			temp.AppendNum(iThreadsInfoArr[i].iStartServerErr);

			temp.Append(KPostfix);

			testfailed = ETrue;

			}

		if( KErrNone != iThreadsInfoArr[i].iAddFeatErr )

			{

			temp.Append(_L("RFeatureControl::AddFeature expects KErrNone, error value: "));

			temp.AppendNum(iThreadsInfoArr[i].iAddFeatErr);

			temp.Append(KPostfix);

			testfailed = ETrue;

			}

		if( KErrNotFound != iThreadsInfoArr[i].iSetFeatErr )

			{

			temp.Append(_L("RFeatureControl::SetFeature expects KErrNotFound, error value: "));

			temp.AppendNum(iThreadsInfoArr[i].iSetFeatErr);

			temp.Append(KPostfix);

			testfailed = ETrue;

			}

		if( KFeatureSupported != iThreadsInfoArr[i].iDetailsFeatErr )

			{

			temp.Append(_L("RFeatureControl::FeatureSupported expects KFeatureSupported, error value: "));

			temp.AppendNum(iThreadsInfoArr[i].iDetailsFeatErr);

			temp.Append(KPostfix);

			testfailed = ETrue;

			}	

		if( KErrNone != iThreadsInfoArr[i].iDeleteFeatErr )

			{

			temp.Append(_L("RFeatureControl::DeleteFeature expects KErrNone, error value: "));

			temp.AppendNum(iThreadsInfoArr[i].iDeleteFeatErr);

			temp.Append(KPostfix);

			testfailed = ETrue;

			}				

		if( KErrNone != iThreadsInfoArr[i].iRequestNotif )

			{

			temp.Append(_L("CFeatureNotifier::NotifyRequest expects KErrNone, error value: "));

			temp.AppendNum(iThreadsInfoArr[i].iRequestNotif);

			temp.Append(KPostfix);

			testfailed = ETrue;

			}

		if( KErrNone != iThreadsInfoArr[i].iSetFeatNotif )

			{

			temp.Append(_L("RFeatureControl::SetFeature after notification request expects KErrNone, error value: "));

			temp.AppendNum(iThreadsInfoArr[i].iSetFeatNotif);

			temp.Append(KPostfix);

			testfailed = ETrue;

			}

		if( testfailed )

			{

			TESTDIAGNOSTICERROR(EFalse, temp, i);

			}

		}

	return TestStepResult();	

	}

void CFeatMgrStressTest::DoThreadActionL()

	{

	TThreadId id = RThread().Id();

	TUid uid = {id.Id()};

	// Create the thread info instance that would hold the results for the tests below

	TThreadTestInfo info;

	info.iId = uid.iUid;

	// A. Create a session to the server 

	RFeatureControl control;

	info.iStartServerErr = control.Open();		// Expected: KErrNone

	// B. Adding new feature	

	TBitFlags32  flags( 0 );

    flags.Set( EFeatureSupported );

    flags.Set( EFeatureModifiable );  

	TFeatureEntry newEentry( uid, flags, KDefaultData1 );

	info.iAddFeatErr = control.AddFeature( newEentry );		// Expected: KErrNone

	// C. Setting an unexisting feature

	info.iSetFeatErr = control.SetFeature(KUnknownUid, ETrue, 4);		// Expected: KErrNotFound

	// D. Requesting feature details

	info.iDetailsFeatErr = control.FeatureSupported( uid );				// Expected: KFeatureSupported

	// E. Add notification for some feature	

	// Create an active scheduler

	CActiveScheduler* activescheduler = new(ELeave) CActiveScheduler();

    CleanupStack::PushL(activescheduler); 

    // Install the active scheduler 

    CActiveScheduler::Install(activescheduler);

 	// Create a notifier

	CFeatureNotifier *notif = NULL;

	// Creating the notifier observer

	CNotifierObserver* pObserver = new(ELeave) CNotifierObserver();

	MFeatureObserver* pntr = (MFeatureObserver*)( pObserver ); 

	notif = CFeatureNotifier::NewL(*pntr);    

    CleanupStack::PushL( notif );	

    info.iRequestNotif = notif->NotifyRequest( uid );				// Expected: KErrNone

    info.iSetFeatNotif = control.SetFeature(uid, KChangeData);		// Expected: KErrNone

    CActiveScheduler::Start();

    CActiveScheduler::Install(NULL);

	CleanupStack::PopAndDestroy(2);

	// F. Delete added feature	

	info.iDeleteFeatErr = control.DeleteFeature( uid );			// Expected: KErrNone

	// Closing the session to featmgr server

	control.Close();

	iSection.Wait();	

	iThreadsInfoArr.Append(info);		

	if( (++iThreadsCount) == THREADS )

		{

		RSemaphore semaphore;

		User::LeaveIfError(semaphore.OpenGlobal(_L("ThreadsSemaphore")));

		semaphore.Signal();

		iSection.Signal();

		return;

		}

	iSection.Signal();

	}

TInt CFeatMgrStressTest::ThreadeEntryPoint( TAny* aPtrThis)

	{

	// Creating the cleanup stack for the thread

	CTrapCleanup* cleanupStack = CTrapCleanup::New();

	TRAPD( err, ((CFeatMgrStressTest*) aPtrThis)->DoThreadActionL() );

	__ASSERT_ALWAYS(!err, User::Panic(_L("Thread panic"),err));

	// deleting the cleanup stack for the thread

	delete cleanupStack;

 	return 1;

	}

CMulticonnectionTestStep1::CMulticonnectionTestStep1()

   {

   SetTestStepName(KMulticonnectionTest1);

   }

TVerdict CMulticonnectionTestStep1::doTestStepL()

   {

   //Create RFeatureControl object

   RFeatureControl control;

   TInt err = control.Connect();       

   CleanupClosePushL( control );

   //Create a connection via FeatureManager          

   TRAP(err, FeatureManager::InitializeLibL());   

   //request feature information using CFeatureDiscovery class

   TBool supported( CFeatureDiscovery::IsFeatureSupportedL(KDefaultSupportedUid) );

   TESTDIAGNOSTIC(supported,

		   _L("Feature state request using FeatureDiscovery failed: the feature is expected to be supported"));

   //set feature state using RFeatureControl object

   err = control.SetFeature(KDefaultSupportedUid, EFalse, 0);

   TESTDIAGNOSTICERROR(err==KErrNone,

		   _L("Feature state setting failed: error = %d"),err);

   //request feature state using FeatureManager

   supported = FeatureManager::FeatureSupported( KDefaultSupportedUid.iUid );

   TESTDIAGNOSTICERROR(supported==KFeatureUnsupported,

		   _L("Feature state request using FeatureManager failed, KFeatureUnsupported expected, returned value is = %d"),supported);

   //close FeatureManager connection

   FeatureManager::UnInitializeLib(); 

   //request feature state using RFeatureControl

   supported = control.FeatureSupported( KDefaultSupportedUid );  

   TESTDIAGNOSTICERROR(supported==KFeatureUnsupported,

		   _L("Feature state request using FeatureControl failed, KFeatureUnsupported expected, returned value is = %d"),supported);

   CleanupStack::PopAndDestroy( &control );

   return TestStepResult();

   }

CMulticonnectionTestStep2::CMulticonnectionTestStep2()

   {

   SetTestStepName(KMulticonnectionTest2);

   }

TVerdict CMulticonnectionTestStep2::doTestStepL()

	{

	//request feature information using CFeatureDiscovery class

	TBool supported( CFeatureDiscovery::IsFeatureSupportedL(KDefaultUnsupportedUid) );

	TESTDIAGNOSTIC(!supported,

		   _L("Feature state request using FeatureDiscovery failed: the feature is expected to be unsupported"));

	supported = CFeatureDiscovery::IsFeatureSupportedL(KModifiableUid);

	TESTDIAGNOSTIC(supported,

		   _L("Feature state request using FeatureDiscovery failed: the feature is expected to be supported"));

	supported = CFeatureDiscovery::IsFeatureSupportedL(KUnmodifiableUid);

	TESTDIAGNOSTIC(supported,

		   _L("Feature state request using FeatureDiscovery failed: the feature is expected to be supported"));

	supported = CFeatureDiscovery::IsFeatureSupportedL(KUninitializedUid);

	TESTDIAGNOSTIC(!supported,

		   _L("Feature state request using FeatureDiscovery failed: the feature is expected to be unsupported"));

	return TestStepResult();

	}

CPluginIgnoringTestStep::CPluginIgnoringTestStep()

   {

   SetTestStepName(KPluginIgnoringTest);

   }

TVerdict CPluginIgnoringTestStep::doTestStepL()

	{

   //first we need to check whether the plugin is present in the plugin foled on the C:-drive

    RProcess helperProcess;

    TInt err =helperProcess.Create(_L("pluginhelper.exe"),_L("-? c:\\resource\\plugins\\normal_plugin.rsc"));

    TESTDIAGNOSTICERROR(err==KErrNone,

			   _L("failed to create helper process, returned value is = %d"),err);

	TRequestStatus status;    

    helperProcess.Rendezvous(status);

    helperProcess.Resume();	

 	User::WaitForRequest(status);

    if (helperProcess.ExitReason()==KErrNotFound)

    	{

    	INFO_PRINTF1(_L("Plugin file was not found in the plugin folder, test is not performed"));

    	return TestStepResult();

    	}

	RFeatureControl control;

	err = control.Connect();       	

	TESTDIAGNOSTICERROR(err==KErrNone,

			   _L("RFeatureControl::Connect failed, returned value is = %d"),err);

	err = control.FeatureSupported( KPluginIgnoringUid );

	TESTDIAGNOSTICERROR(err==KErrNotFound,

			   _L("C:-drive based plugin has not been ignored, the feature is expected to be not found, returned value is = %d"),err);

	control.Close();

	return TestStepResult();

	}

CNotificationHandler::CNotificationHandler(TInt aHandlerID, MNotificationOrderVerifier* aNotificationOrderVerifier) : 

iNotificationOrderVerifier(aNotificationOrderVerifier),

iID(aHandlerID)

	{

	}

void CNotificationHandler::HandleNotifyChange( TFeatureChangeType, TFeatureEntry aFeature )

	{

	iNotificationOrderVerifier->OnNotification(iID, aFeature.FeatureUid().iUid);	

	}

void CNotificationHandler::HandleNotifyError( TInt /*aError*/ ) 

	{

	}

CMultipleNotificationRequestsStep::CMultipleNotificationRequestsStep()

	{

	SetTestStepName(KMultipleNotificationRequests);

	}

TVerdict CMultipleNotificationRequestsStep::doTestStepPreambleL(void)

	{

	notificationHandler1 =  new (ELeave)CNotificationHandler(CNotificationHandler::EHandler1, this);

	CleanupStack::PushL( notificationHandler1 );

	notificationHandler2 =  new (ELeave)CNotificationHandler(CNotificationHandler::EHandler2, this);

	CleanupStack::Pop( notificationHandler1 );

	return TestStepResult();

	}

TVerdict CMultipleNotificationRequestsStep::doTestStepPostambleL(void)

	{

	delete notificationHandler1;

	delete notificationHandler2;

	return TestStepResult();

	}

TVerdict CMultipleNotificationRequestsStep::doTestStepL()

	{

	// Install the active scheduler

	CActiveScheduler* activescheduler = new(ELeave) CActiveScheduler();

	CleanupStack::PushL(activescheduler); 	 

	CActiveScheduler::Install(activescheduler);

	TInt err = KErrNone;

	// Creating notifiers

	CFeatureNotifier* notif1 = CFeatureNotifier::NewL(*notificationHandler1);

	CleanupStack::PushL( notif1 );

	CFeatureNotifier* notif2 = CFeatureNotifier::NewL(*notificationHandler2);	

	CleanupStack::PushL( notif2 );

	TBitFlags32 flags( 0 );

	flags.Set( EFeatureSupported);

	flags.Set( EFeatureModifiable );

	TFeatureEntry entry1( KNewUid1, flags, KDefaultData1 );

	TFeatureEntry entry2( KNewUid2, flags, KDefaultData1 );

	RFeatureControl control;

	err = control.Open();

	CleanupClosePushL( control );

	TESTDIAGNOSTICERROR(err==KErrNone,

		_L("RFeatureControl::Open failed, returned value is = %d"),err);			 

	err = control.AddFeature(entry1);

	TESTDIAGNOSTICERROR(err==KErrNone||err==KErrAlreadyExists,

		_L("RFeatureControl::AddFeature failed, returned value is = %d"),err);

	err = control.AddFeature(entry2);	

	TESTDIAGNOSTICERROR(err==KErrNone||err==KErrAlreadyExists,

		_L("RFeatureControl::AddFeature failed, returned value is = %d"),err);

	err = notif1->NotifyRequest( KNewUid1 );

	TESTDIAGNOSTICERROR(err==KErrNone,

		_L("CFeatureNotifier::NotifyRequest failed, returned value is = %d"),err);

	err = notif2->NotifyRequest( KNewUid2 );

	TESTDIAGNOSTICERROR(err==KErrNone,

		_L("CFeatureNotifier::NotifyRequest failed, returned value is = %d"),err);

	control.SetFeature(KNewUid1, KChangeData);

	TESTDIAGNOSTICERROR(err==KErrNone,

		_L("RFeatureControl::SetFeature failed, returned value is = %d"),err);		

	control.SetFeature(KNewUid2, KChangeData);

	TESTDIAGNOSTICERROR(err==KErrNone,

		_L("RFeatureControl::SetFeature failed, returned value is = %d"),err);

	if (TestStepResult() == EFail)

		return TestStepResult();		

	CActiveScheduler::Start();

	control.DeleteFeature(KNewUid1);

	control.DeleteFeature(KNewUid2);

	CleanupStack::PopAndDestroy( &control );

	CleanupStack::PopAndDestroy( notif2 );

	CleanupStack::PopAndDestroy( notif1 );

	CleanupStack::PopAndDestroy( activescheduler );

	return TestStepResult();

	}

// This function is defined so that CSingleNotificationRequest1 and CSingleNotificationRequest2

// objects are able to print to TEF log files. It was not possible to print from within their

// HandleNotifyChange functions.

void CMultipleNotificationRequestsStep::OnNotification(TInt aHandlerID, TInt aFeatureID)

	{

	if( aHandlerID == CNotificationHandler::EHandler1 )

		{

		TESTDIAGNOSTICERROR(aFeatureID == KNewUid1.iUid, _L("CSingleNotificationRequest1::HandleNotifyChange - feature KNewUid1 is expected; feature recevied = %d"), aFeatureID );

		}

	else if( aHandlerID == CNotificationHandler::EHandler1 )

		{

		TESTDIAGNOSTICERROR(aFeatureID == KNewUid2.iUid, _L("CSingleNotificationRequest2::HandleNotifyChange - feature KNewUid2 is expected; feature recevied = %d"), aFeatureID );

		}

	if (++iNotificationCounter == 2)

		{

		CActiveScheduler::Stop();

		}

	}

CFeatmgrStartEndInstall::CFeatmgrStartEndInstall()

	{

	SetTestStepName(KFeatmgrStartEndInstall);

	}

TVerdict CFeatmgrStartEndInstall::doTestStepL()

	{

	RFeatureControl control;

	TInt err(KErrNone);

	err = control.Open();       	

	TESTDIAGNOSTICERROR(err==KErrNone,

			   _L("RFeatureControl::Open failed, returned value is = %d"),err);

	/*

	* General Test Cases

	*/

	////////////////////////////////////////////////////////////////////////////////////////////

	// SCENARIO 1: Calling SWIStart without SWI running

	// SWIStart

	////////////////////////////////////////////////////////////////////////////////////////////

	INFO_PRINTF1(_L("SCENARIO 1: Calling SWIStart without SWI running"));

	err = control.SWIStart();

	TESTDIAGNOSTICERROR(err==KErrNotReady, 

			_L("RFeatureControl::SWIStart expects KErrNotReady; returned value is = %d"),err);

	// Wait before starting the next test

	User::After(100000);

	////////////////////////////////////////////////////////////////////////////////////////////

	// SCENARIO 2: Call SWIEnd without SWI running 

	// SWIEnd

	////////////////////////////////////////////////////////////////////////////////////////////

	INFO_PRINTF1(_L("SCENARIO 2: Call SWIEnd without SWI running"));

	err = control.SWIEnd();

	TESTDIAGNOSTICERROR(err==KErrNotReady, 

			_L("RFeatureControl::SWIEnd expects KErrNotReady; returned value is = %d"),err);

	control.Close();

	// Wait before starting the next test

	User::After(100000);

	/*

	* SWI Installation Test Cases 

	*/

	// Locals for the test scenarios

	RProcess process; 

	TBitFlags32 flags( 0 ); 	

	flags.Set( EFeatureSupported);

	flags.Set( EFeatureModifiable );

	TFeatureEntry entry1( KNewUid1, flags, KDefaultData1 );

	TFeatureEntry entry3( KNewUid3, flags, KDefaultData1 );

	TFeatureEntry query1(KNewUid1);

	TFeatureEntry query3(KNewUid3);

	TUint32 data;

	////////////////////////////////////////////////////////////////////////////////////////////

	// SCENARIO 3: Successful installation and features manipulation

	// P&S install -> SWIStart -> SWIEnd -> P&S success

	////////////////////////////////////////////////////////////////////////////////////////////

	INFO_PRINTF1(_L("SCENARIO 3: Successful installation and features manipulation"));