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

// This file contains test classes and their implementations

// to test production class CDiscoverer. Where necessary stubs

// are implemented to help in writing test harness using RTest.

// 

//

#include "Discoverer.h"

#include "EComErrorCodes.h"

#include "ImplementationInformation.h"

#include "DiscovererObserver.h"

#include "../EcomTestUtils/EcomTestUtils.h"

#include "EComUidCodes.h"

#include "RegistryData.h"

#include "DriveInfo.h"

#include <ecom/ecompanics.h>

#include <e32test.h>

#include <bautils.h>

#include <s32file.h>

#include <barsread2.h>

#include <e32uid.h>

#include <startup.hrh>

#include "baspi.h"

#include <sacls.h>

//New RSC based plugins

_LIT(KNewResourceFileName,		 		"C:\\resource\\plugins\\EComExample5.rsc");

_LIT(KNewExampleDllFileName,	 		"C:\\sys\\bin\\EComExample5.dll");

_LIT(KNewResourceFileNameOnZ,   		"z:\\RAMOnly\\EComExample5.rsc");

_LIT(KNewExampleDllFileNameOnZ, 		"z:\\RAMOnly\\EComExample5.dll");

_LIT(KNewExampleDllFileNameOnly,		"EComExample5.dll");

_LIT(KNewResourceSearchPath,			"\\resource\\plugins\\*");

//PlugIn3 RSC based plugins

_LIT(KPlugIn3ResourceFileName,		 		"C:\\resource\\plugins\\EComExample12.rsc");

_LIT(KPlugIn3ExampleDllFileName,	 		"C:\\sys\\bin\\EComExample12.dll");

_LIT(KPlugIn3ResourceFileNameOnZ,   		"z:\\RAMOnly\\EComExample12.rsc");

_LIT(KPlugIn3ExampleDllFileNameOnZ, 		"z:\\RAMOnly\\EComExample12.dll");

_LIT(KPlugIn3ExampleDllFileNameOnly,		"EComExample12.dll");

//Old DLL based plugins

// spi test file

_LIT(KEComSpiTestFilePathAndName, "Z:\\Test\\Data\\EcomTest.spi");

_LIT(KEComSpiTestFilePlugIn3PathAndName, "Z:\\Test\\Data\\EcomTestType3.spi");

// file name detremined from example spi file

_LIT(KEComSpiTestFileDllPathAndName, "Z:\\sys\\bin\\EComExample5.dll");

_LIT(KEComSpiTestFilePlugIn3DllPathAndName, "Z:\\sys\\bin\\EComExample12.dll");

// spi file

_LIT(KEComSPIFilePathAndName, "Z:\\private\\10009D8F\\Ecom.spi");

const TInt KOneSecond = 1000000;

LOCAL_D RFs	TheFs;

LOCAL_D RTest test(_L("t_discoverer.exe"));

LOCAL_D CTrapCleanup* 	  TheTrapCleanup 	 = NULL;

LOCAL_D CActiveScheduler* TheActiveScheduler = NULL;

// Used for supressing warning in OOM tests

#define __UNUSED_VAR(var) var = var

// Used for OOM test

#define TEST_OOM_ERR if(err == KErrNoMemory) User::Leave(err)

/**

Stub classes are provided to act as replacement members for the class

under test. This ensures the test class is constructed correctly and its

behaviour is also correct within the context of the test. It allows the

class to be tested in isolation. Other tests are available that test the

interoperability of the class

*/

class CObserverStub : public CBase, public MDiscovererObserver

{

public:

	enum OSState

		{

		OSS_Undefined,

		OSS_NoPlugins,

		OSS_CriticalPlugins,

		OSS_DiscoverNonCriticalPlugins,

		OSS_AllPlugins

		};

	static CObserverStub* NewL();

	virtual ~CObserverStub();

	// Inherited from MDiscovererObserver

	virtual void DiscoveriesBegin();

	virtual void RegisterDiscoveryL(const TDriveName& aDrive,CPluginBase*& aDirEntry,TBool aDatFileExists);

	virtual void DiscoveriesComplete(TBool aSuccessful, TPluginProcessingTypeIdentifier aProcessingType);

	virtual void DriveRemovedL(TDriveUnit aDrive);

	virtual void DriveReinstatedL(TDriveUnit aDrive);

	virtual void DriveIsSpiBasedL(const TDriveUnit& /*aDrive*/){}

	virtual TBool NotifiedWithErrorCode(TInt aError);

	virtual TBool IsAnyDllRegisteredWithDriveL(const TDriveUnit aDrive) const;

	virtual void SetDiscoveryFlagL(const TDriveUnit &aDrive);

	virtual void LanguageChangedL(TBool& aLanguageChanged);

	// Result verifing methods

	TBool IsDriveMounted(const TDriveUnit aDrive);

	TBool IsEntryProcessed(CPluginBase*& aDirEntry);

	//TBool IsSpiEntryProcessed(const TEntry& aEntry);

	TBool IsDiscoveriesCompleteSuccessfully();

	void SetDiscoverer(CDiscoverer* aDiscoverer);

	OSState GetState();

private:

	CObserverStub();

private:

	/** Base class ecom entry */

	CPluginBase* iEntryBase;

	/** Information of the dll which contains interface implementations */

	//TEComEntryDetails		iEntry;

	/** Information of the spi file which contains interface implementations */

	//TEComSpiResourceEntryDetails		iSpiEntry;

	/** iDriveUnit is drive mounted */

	TDriveUnit	iDriveUnit;

	/** Flag to indicate whether iDriveUnit is mounted or not */

	TBool		iDriveMounted;

	/** Flag to indicate whether iEntry is processed or not */

	TBool		iEntryProcessed;

	/** Flag to indicate whether iSpiEntry is processed or not */

	TBool		iSpiEntryProcessed;

	/** Flag to indicate whether Discovery process is Complete or not */

	TBool		iDiscoveriesComplete;

	/** The current start-up state of this object */

	OSState     iState;

	/** A reference to the CDiscoverer object that this class is observing*/

	CDiscoverer* iDiscoverer;

};  // End of CObserverStub declaration

/**

The TDiscoverer_StateAccessor class allows to access the private and protected

members of production code class CDiscoverer, as its a friend class.

*/

class TDiscoverer_StateAccessor

	{

public:

	// Auxiliary functions that provide access to

	// CDiscoverer private/protected members

	void ScanDirectoryL(CDiscoverer& aDiscoverer, TDriveUnit aDriveUnit);

	void ScanDirectoryCancel(CDiscoverer& aDiscoverer);

	void CompleteNotificationProcessing(CDiscoverer& aDiscoverer);

	void ValidateEntryL(CDiscoverer& aDiscoverer,

						const TEntry& aEntry,

						const TDriveName& aDriveName,

						CPluginBase*& aEntryToFill,

						TBool aIsRO);

	void ValidateEntryL(CDiscoverer& aDiscoverer,

						RResourceArchive& aRscArchive,

						CPluginBase*& aEntryToFill);

	void ProcessEntryL(CDiscoverer& aDiscoverer,const TDriveName& aDrive, CPluginBase*& aEntry, TBool aDatFileExists);

	void DriveMountedL(CDiscoverer& aDiscoverer, const TDriveUnit aDrive);

	void DriveUnmountedL(CDiscoverer& aDiscoverer, const TDriveUnit aDrive);

	void SwiChangeNotificationL(CDiscoverer& aDiscoverer, TInt aSwiOperation);

	void IdleScanningTimerRunErrorL(CDiscoverer& aDiscoverer, TInt aError);

	void DirChangeNotifierRunErrorL(CDiscoverer& aDiscoverer, TInt aError);

	void SwiChangeNotifierRunError(CDiscoverer& aDiscoverer, TInt aError);

	// Verification functions to check the state of CDiscoverer object against tests

	TBool IsDriveMounted(CDiscoverer& aDiscoverer, const TDriveUnit aDrive);

	TBool IsDiscovererActive(CDiscoverer& aDiscoverer);

	TBool IsDirectoryScanCancelled(CDiscoverer& aDiscoverer);

	TBool IsScanDirectoryComplete(CDiscoverer& aDiscoverer);

	TBool IsScanDirectoryPending(CDiscoverer& aDiscoverer, TDriveUnit aDrive);

	TUint PendingDriveListCount(CDiscoverer& aDiscoverer);

	CDiscoverer::TDiscovererState State(CDiscoverer& aDiscoverer);

	CObserverStub::OSState GetDiscovererObserverState(CDiscoverer& aDiscoverer);

	void ScanDriveL(CDiscoverer& aDiscoverer, TDriveUnit aDrive,  TBool aIsRO);

	void LanguageChangedL(CDiscoverer& aDiscoverer);

	};

/**

Scans plugin directories

@param		aDiscoverer The CDiscoverer class object under test

@return		void

*/

void TDiscoverer_StateAccessor::ScanDirectoryL(CDiscoverer& aDiscoverer, TDriveUnit aDriveUnit)

	{

	aDiscoverer.RediscoveryScanDirectoryL(aDriveUnit);

	}

/**

Stops scanning of the plugin directories

@param		aDiscoverer The CDiscoverer class object under test

*/

void TDiscoverer_StateAccessor::ScanDirectoryCancel(CDiscoverer& aDiscoverer)

	{

	aDiscoverer.ScanDirectoryCancel();

	}

/**

Signals that the directory change has been fully processed.

@param		aDiscoverer The CDiscoverer class object under test

*/

void TDiscoverer_StateAccessor::CompleteNotificationProcessing(CDiscoverer& aDiscoverer)

	{

	aDiscoverer.CompleteNotificationProcessing();

	}

/**

Verifies that the discovered entry is valid.

Used to test the Interface Implementation Collection entry

@param		aDiscoverer The CDiscoverer class object under test

@param		aEntry The plugin name

@param		aDriveName The drive containing the entry

@param		aEntryToFill On return points to complete

			plugin file name(with path) i.e. aPath + aEntry

*/

void TDiscoverer_StateAccessor::ValidateEntryL(CDiscoverer& aDiscoverer,

											   const TEntry& aEntry,

											   const TDriveName& aDriveName,

											   CPluginBase*& aEntryToFill,

											   TBool aIsRO)

	{

	aDiscoverer.ValidateEntryL(aEntry, aDriveName, aEntryToFill, aIsRO);

	}

/**

Verifies that the discovered entry is valid.

Used to test the Interface Implementation Collection entry

@param		aDiscoverer The CDiscoverer class object under test

@param		aRscArchive reference to the resource archive

@param		aEntryToFill On return points to complete

			plugin file name(with path) i.e. aPath + aEntry

*/

void TDiscoverer_StateAccessor::ValidateEntryL(CDiscoverer& aDiscoverer,

											RResourceArchive& aRscArchive,

											CPluginBase*& aEntryToFill)

	{

	aDiscoverer.ValidateEntryL(aRscArchive,aEntryToFill);

	}

/**

Registers an Interface Implementation Collection

@param		aDiscoverer The CDiscoverer class object under test

@param		aEntry This is the plugin name that needs to be registered

*/

void TDiscoverer_StateAccessor::ProcessEntryL(CDiscoverer& aDiscoverer,const TDriveName& aDrive,

										  CPluginBase*& aEntry, TBool aDatFileExists)

	{

	aDiscoverer.ProcessEntryL(aDrive,aEntry,aDatFileExists);

	}

/**

Notifies the discoverer of an SWI operation change

@param		aDiscoverer The CDiscoverer class object under test

@param		aSwiOperation This new SWI state

*/

void TDiscoverer_StateAccessor::SwiChangeNotificationL(CDiscoverer& aDiscoverer, TInt aSwiOperation)

	{

	aDiscoverer.SwiChangeNotificationL(aSwiOperation);

	}

/**

Signals that a drive is available

@param		aDiscoverer The CDiscoverer class object under test

@param		aDrive Drive that needs to be mounted

*/

void TDiscoverer_StateAccessor::DriveMountedL(CDiscoverer& aDiscoverer,

											  const TDriveUnit aDrive)

	{

	aDiscoverer.DriveMountedL(aDrive);

	}

/**

Signals that a drive is unavailable

@param		aDiscoverer The CDiscoverer class object under test

@param		aDrive Drive that needs to be unmounted/removed

*/

void TDiscoverer_StateAccessor::DriveUnmountedL(CDiscoverer& aDiscoverer,

												const TDriveUnit aDrive)

	{

	aDiscoverer.DriveUnmountedL(aDrive);

	}

/**

Checks whether CDiscoverer object has successfully completed with

the scanning of the plugin directories on all drives

@param		aDiscoverer The CDiscoverer class object under test

@return		true if notification has been processed on all drives.

			false if there is notification processing pending on any drive

*/

TBool TDiscoverer_StateAccessor::IsScanDirectoryComplete(CDiscoverer& aDiscoverer)

	{

	// check state of discoverer to see if all pending drives have been scanned.

	return(aDiscoverer.State() == CDiscoverer::EDisc_AllPluginsDisc);

	}

/**

Checks whether a notification has been signaled but not processed on specified drive.

Error Condition	: Leaves with KErrNotFound if the drive is not registered.

@param		aDiscoverer The CDiscoverer class object under test

@param		aDrive The drive to check

@return		true if notification has been processed on the specified drive.

			false if notification processing is pending

*/

TBool TDiscoverer_StateAccessor::IsScanDirectoryPending(CDiscoverer& aDiscoverer, TDriveUnit aDrive)

	{

	if(aDiscoverer.iScanningTimer->iPendingDriveList.Find(aDrive)!=KErrNotFound)

		{

		return ETrue;

		}

	else

		{

		return EFalse;

		}

	}

/**

Checks the current count of drives in the list waiting for processing.

@param		aDiscoverer The CDiscoverer class object under test

@return		TUint

*/

TUint TDiscoverer_StateAccessor::PendingDriveListCount(CDiscoverer& aDiscoverer)

	{

	return(aDiscoverer.iScanningTimer->iPendingDriveList.Count());

	}

/**

Checks that CDiscoverer object is not scanning the plugin directories.

@param		aDiscoverer The CDiscoverer class object under test

@return		true if plugin dirctory scanning is stopped.

*/

TBool TDiscoverer_StateAccessor::IsDirectoryScanCancelled(CDiscoverer& aDiscoverer)

	{

	if(!aDiscoverer.iDirScanner)

		{

		return ETrue;

		}

	return EFalse;

	}

/**

Checks that CDiscoverer object is currently activated for the plugin dir scanning

@param		aDiscoverer The CDiscoverer class object under test

@return		true if Discoverer object is tracking changes in the plugin directories in each drive.

*/

TBool TDiscoverer_StateAccessor::IsDiscovererActive(CDiscoverer& aDiscoverer)

	{

	//Return ETrue if both iScanningTimer & directory notifier(s) are active

	TBool isActive = ETrue;

	  for(TInt index = 0; index <aDiscoverer.iRscDirNotifierList.Count(); index++)

	  	{

	  	if(!(aDiscoverer.iRscDirNotifierList[index]&& aDiscoverer.iRscDirNotifierList[index]->IsActive()))

			{

			// iRscDirNotifierList should be active, as each active object on list is constantly

			// looking for changes in the plugin directories in each drive.

			isActive = EFalse;

			break;

			}

		}

	return isActive;

	}

/**

Verifies whether given drive is registered

@param		aDiscoverer The CDiscoverer class object under test

@param		aDrive Drive that needs to be verified for registration

@return		return true if given drive is installed

*/

TBool TDiscoverer_StateAccessor::IsDriveMounted(CDiscoverer& aDiscoverer,

												const TDriveUnit aDrive)

	{

	TBool isMounted = ETrue;

	if(aDiscoverer.iDrivesDiscovered.Find(aDrive) == KErrNotFound)

		{

		isMounted = EFalse;

		}

	return isMounted;

	}

/**

Scans plugin directories

@param		aDiscoverer The CDiscoverer class object under test

@param 		aDrive	The drive which is scanned

@param		aIsRO	Whether the drive is ready-only

@return		true if plugin directorie in each drive get scaned successfully

*/

void TDiscoverer_StateAccessor::ScanDriveL(CDiscoverer& aDiscoverer, TDriveUnit aDrive,  TBool aIsRO)

	{

	return aDiscoverer.iDirScanner->ScanDriveL(aDrive, aIsRO);

	}

void TDiscoverer_StateAccessor::LanguageChangedL(CDiscoverer& aDiscoverer)

	{

	aDiscoverer.LanguageChangeNotificationL();

	}

/**

Retrieve the object's current state.

@param		aDiscoverer The CDiscoverer class object under test

@return 	TDiscovererState the current state of the CDiscoverer

class object under test

*/

CDiscoverer::TDiscovererState TDiscoverer_StateAccessor::State(CDiscoverer& aDiscoverer)

	{

	return aDiscoverer.State();

	}

CObserverStub::OSState TDiscoverer_StateAccessor::GetDiscovererObserverState(CDiscoverer& aDiscoverer)

	{

	CObserverStub* discovererObserver =

		static_cast<CObserverStub*>(&aDiscoverer.iDiscovererObserver);

	return discovererObserver->GetState();

	}

/**

Call the CIdleScanningTimer RunError funtion

@param		aDiscoverer The CDiscoverer class object under test

@param 		aError The error code to pass to the RunError function

*/

void TDiscoverer_StateAccessor::IdleScanningTimerRunErrorL(CDiscoverer& aDiscoverer, TInt aError)

	{

	aDiscoverer.iScanningTimer->RunError(aError);

	}

/**

Call the CDirChangeNotifier RunError funtion

@param		aDiscoverer The CDiscoverer class object under test

@param 		aError The error code to pass to the RunError function

*/

void TDiscoverer_StateAccessor::DirChangeNotifierRunErrorL(CDiscoverer& aDiscoverer, TInt aError)

	{

	aDiscoverer.iRscDirNotifierList[0]->RunError(aError);

	}

/**

Call the CSwiChangeNotifier RunError funtion

@param		aDiscoverer The CDiscoverer class object under test

@param 		aError The error code to pass to the RunError function

*/

void TDiscoverer_StateAccessor::SwiChangeNotifierRunError(CDiscoverer& aDiscoverer, TInt aError)

	{

	aDiscoverer.iSwiChangeNotifier->RunError(aError);

	}

/**

Creates an instance of CObserverStub class.

@return		The new'ed object.

*/

CObserverStub* CObserverStub::NewL()

	{

	return new(ELeave) CObserverStub();

	}

/**

Destructor

@post		This object is properly destroyed.

*/

CObserverStub::~CObserverStub()

	{

	// do nothing;

	}

/**

Default constructor.

@post		The object is properly constructed.

*/

CObserverStub::CObserverStub()

				:CBase(),

				iDriveUnit(EDriveC),

				iDriveMounted(EFalse),

				iEntryProcessed(EFalse),

				iSpiEntryProcessed(EFalse),

				iDiscoveriesComplete(EFalse),

				iState(OSS_NoPlugins)

	{

	// do nothing;

	}

/**

MDiscovererObserver callback method, to signal that a discovery

session is starting.

*/

void CObserverStub::DiscoveriesBegin()

	{

	iDiscoveriesComplete = EFalse;

	}

void CObserverStub::SetDiscoveryFlagL(const TDriveUnit & /*aDrive*/)

	{

	iDiscoveriesComplete = ETrue;

	}

/**

MDiscovererObserver callback method to register an Ecom Spi file.

@param		aEntry The Ecom file  that needs to be registered

*/

void CObserverStub::RegisterDiscoveryL(const TDriveName& /* aDriveName */,CPluginBase*& aEntry,TBool /* aDatFileExists*/)

	{

	iEntryBase = aEntry;

	iSpiEntryProcessed = ETrue;

	}

/**

MDiscovererObserver callback method, to signal that a discovery

session is complete.

@param		aSuccessful Indicates discoveries process completed successfully or not

@param		aProcessingType indicates the type of processing for plugins

			for ensuring that plugins are not processed multiple times

			during start-up phase

*/

void CObserverStub::DiscoveriesComplete(TBool aSuccessful, TPluginProcessingTypeIdentifier aProcessingType)

	{

	iDiscoveriesComplete = aSuccessful;

	switch(iState)

		{

		case OSS_NoPlugins:

			if(aProcessingType == EPluginProcessingTypeCriticalOnly &&

			   iDiscoverer->State() == CDiscoverer::EDisc_CriticalPluginsDisc)

				{

				iState = OSS_CriticalPlugins;

				}

			else if(aProcessingType == EPluginProcessingTypeAll &&

				    iDiscoverer->State() == CDiscoverer::EDisc_AllPluginsDisc)

				{

				iState = OSS_AllPlugins;

				}

			break;

		case OSS_CriticalPlugins:

			if(aProcessingType == EPluginProcessingTypeNonCriticalOnly &&

			   iDiscoverer->State() == CDiscoverer::EDisc_AllPluginsDisc)

				{

				iState = OSS_AllPlugins;

				}

			break;

		}

	}

/**

Verifies whether given plugin entry is registered

@param		aDirEntry The Ecom plugin that to be checked for registration.

@return		true if given plugin is registered

*/

TBool CObserverStub::IsEntryProcessed(CPluginBase*& aDirEntry)

	{

	if(iEntryProcessed && (iEntryBase->iDllThirdUid == aDirEntry->iDllThirdUid))

		{

		return ETrue;

		}

	return EFalse;

	}

/**

MDiscovererObserver callback method, to signal that a Drive

is removed/dismounted.

@param		aDrive The drive that is removed.

*/

void CObserverStub::DriveRemovedL(TDriveUnit aDrive)

	{

	iDriveMounted = EFalse;

	iDriveUnit = aDrive;

	}

/**

MDiscovererObserver callback method, to signal that a Drive

is reinstalled.

@param		aDrive The drive that is available now.

*/

void CObserverStub::DriveReinstatedL(TDriveUnit aDrive)

	{

	iDriveMounted = ETrue;

	iDriveUnit = aDrive;

	}

/**

MDiscovererObserver callback method, to signal that

during a discovery session an error has occured.

@param		aError The notification error code.

@return		true if aError is one of the acceptable error codes

*/

TBool CObserverStub::NotifiedWithErrorCode(TInt aError)

	{

	// Test the safe error codes

	return (aError == KErrNotReady ||		// Drive removed

			aError == KErrPathNotFound);	// Directory deleted

	}

/**

MDiscovererObserver callback method,to retrieve the drive unit's DAT

file infor.

@param 		aDrive the identifier of the drive to retrieve DAT file infor from.

@return		ETrue if DAT file exists on the drive unit, otherwise EFlase.

*/

TBool CObserverStub::IsAnyDllRegisteredWithDriveL(const TDriveUnit /*aDrive*/) const

	{

	// To pass the build always returns EFalse to mean no Dll is discovered in the drive,

	// it is not used in this test.

	return EFalse;

	}

/**

Verification method that checks whether given drive is available

@param		aDrive The drive that to be checked.

@return		true if given drive is registered

*/

TBool CObserverStub::IsDriveMounted(const TDriveUnit aDrive)

	{

	TBool mounted = EFalse;

	if(iDriveMounted && (aDrive == iDriveUnit))

		{

		mounted = ETrue;

		}

	return mounted;

	}

/**

Verification method that checks whether discovery process is completed successfully

@return		true if discovery process is completed successfully

*/

TBool CObserverStub::IsDiscoveriesCompleteSuccessfully()

	{

	return iDiscoveriesComplete;

	}

/**

Returns the current start-up state of this object

@return	    The current start-up state of this object

*/

CObserverStub::OSState CObserverStub::GetState()

	{

	return iState;

	}

void CObserverStub::SetDiscoverer(CDiscoverer* aDiscoverer)

	{

	iDiscoverer = aDiscoverer;

	}

void CObserverStub::LanguageChangedL(TBool& aLanguageChanged)

	{

	aLanguageChanged = EFalse;

	}

class CDiscovererTestShutdown : public CTimer

	{

public:

	inline CDiscovererTestShutdown();

	inline void ConstructL();

	inline void StartAfter(TTimeIntervalMicroSeconds32 aTimeInterval);

private:

	void RunL();

	};

inline CDiscovererTestShutdown::CDiscovererTestShutdown()

:CTimer(EPriorityHigh)// Priority set higher than CIdleScanningTimer

	{

	CActiveScheduler::Add(this);

	}

inline void CDiscovererTestShutdown::ConstructL()

	{

	CTimer::ConstructL();

	}

inline void CDiscovererTestShutdown::StartAfter(TTimeIntervalMicroSeconds32 aTimeInterval)

	{

	After(aTimeInterval);

	}

void CDiscovererTestShutdown::RunL()

	{

	CActiveScheduler::Stop();

	}

/**

Test class for object CDiscoverer.

This class provides the parameters and behaviour that

allows this class to behave normally under a test

scenario.

*/

class CDiscovererTest : public CBase

	{

public:

	static CDiscovererTest* NewL();

	virtual ~CDiscovererTest();

	void ResumeSuspendTestL();

	void DriveMountUnmountTestL();

	void ProcessEntryTestL();

	void ProcessSpiEntryTestL();

	void ValidateSpiEntryTestL();

	void ValidateSpiPluginsTestL();

	void ValidateEntryTestL();

	void ProcessEntryPlugIn3TestL();

	void ProcessSpiEntryPlugIn3TestL();

	void ValidateSpiEntryPlugIn3TestL();

	void ValidateEntryPlugIn3TestL();

	void ScanDirectoryIncrementTestL();

	void ScanDirectoryTestL();

	void ScanDirectoryCancelTestL();

	void StagedDiscoveryStateTransitionTestL();

	void AllAtOnceDiscoveryStateTransitionTestL();

	void MultipleNotificationProcessingTestL();

	void SWINotificationProcessingTestL();

	void IdleScanningTimerRunErrorL();

	void DirChangeNotifierRunErrorL();

	void SwiChangeNotifierRunError();

	void LanguageChangedNotificationTestL();

private:

	CDiscovererTest();

	void ConstructL();

public:

	/** The instance of the class under test */

	CDiscoverer* iDiscoverer;

	/** The instance of the state accessor interface */

	TDiscoverer_StateAccessor* iStateAccessor;

	/** The instance of the observer stub of the CDiscoverer */

	CObserverStub* iDiscovererObserver;

	/** Unique Id of the ECOM dll */

	TUid		iDllUid;

	/** The drive on which interface implementations can be found */

	TDriveUnit	iDriveUnit;

	/** Information on a dll which contains interface implementations */

	TEntry		iDllEntry;

	/** A shutdown timer to manipulate the Active Scheduler of testing server */

	CDiscovererTestShutdown	iShutdown;

	CEComCachedDriveInfo* iCachedDriveInfo;

	};

/**

Standardised safe construction which

leaves nothing on the cleanup stack.

@post			CDiscovererTest is fully constructed and initialised

@return			The new'ed object.

*/

CDiscovererTest* CDiscovererTest::NewL()

	{

	CDiscovererTest* self = new (ELeave) CDiscovererTest();

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Default constructor.

@post	The object is properly constructed.

*/

CDiscovererTest::CDiscovererTest()

				:CBase(),

				 iDriveUnit(EDriveC)

	{

	TUid uid1 = {0};

	TUid uid2 = {0};

	iDllUid.iUid	= 0x10009DB6; // Dll Uid for EComRomOnlyExampleOnC.dll

	iDllEntry.iType = TUidType(uid1, uid2, iDllUid);

	}

/**

Destructor.

@post		This object is properly destroyed.

*/

CDiscovererTest::~CDiscovererTest()

	{

	delete iDiscoverer;

	delete iStateAccessor;

	delete iDiscovererObserver;

	delete iCachedDriveInfo;

	}

/**

Standardized 2nd(Initialization) phase of two phase construction.

Creates supporting class objects for the execution of test.

@post			CDiscovererTest is fully constructed.

*/

void CDiscovererTest::ConstructL()

	{

	iStateAccessor		= new(ELeave) TDiscoverer_StateAccessor;

	iDiscovererObserver	= CObserverStub::NewL();

	iDiscoverer			= CDiscoverer::NewL(*iDiscovererObserver, TheFs);

	iDiscovererObserver->SetDiscoverer(iDiscoverer);

	iShutdown.ConstructL();

	iCachedDriveInfo = CEComCachedDriveInfo::NewL(TheFs);

	}

/**

The test executes by first suspending the discoverer then by

resuming it.

@SYMTestCaseID          SYSLIB-ECOM-CT-0716

@SYMTestCaseDesc	    Tests for resuming and suspending Discoverer

@SYMTestPriority 	    High

@SYMTestActions  	    Suspend if Discoverer is active and then resume. Check for the error conditions(OOM)

@SYMTestExpectedResults The test must not fail.

@SYMREQ                 REQ0000

*/

void CDiscovererTest::ResumeSuspendTestL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0716 "));

	// Perform an initial discovery and start the notifiers.

	iDiscoverer->ProcessSSAEventL(EStartupStateNonCritical);

	TBool isDiscActive = iStateAccessor->IsDiscovererActive(*iDiscoverer);

	// Notifiers should be active.

	test(isDiscActive);

	TInt err = iDiscoverer->Suspend();

	TEST_OOM_ERR;

	test(err == KErrNone);

	// Notifiers should still be active.

	isDiscActive = iStateAccessor->IsDiscovererActive(*iDiscoverer);

	test(isDiscActive);

	// Test that there are no drives pending a scan before we copy the plugin.

	test(!iStateAccessor->IsScanDirectoryPending(*iDiscoverer, EDriveC));

	// Raise a plugin change notification on C: drive. This simulates a plugin being copied.

	iDiscoverer->ProcessDNEventL(CDiscoverer::EPluginsModified, EDriveC);

	iDiscoverer->ProcessDNEventL(CDiscoverer::EPluginsRediscover, EDriveC);

	// Test that the drive we copied the plugin to still has a scan pending.

	test(iStateAccessor->IsScanDirectoryPending(*iDiscoverer, EDriveC));

	isDiscActive = iStateAccessor->IsDiscovererActive(*iDiscoverer);

	// Notifiers should still be active.

	test(isDiscActive);

	// Start Active Scheduler and shut it down in 3 secs, it will launch RunL of timer to process

	// all pending notification.

	iShutdown.StartAfter(KOneSecond * 3);

	CActiveScheduler::Start();

	// Check that notifications have not been processed.

	test(!iStateAccessor->IsScanDirectoryComplete(*iDiscoverer));

	err = iDiscoverer->Resume();

	TEST_OOM_ERR;

	test(err == KErrNone);

	isDiscActive = iStateAccessor->IsDiscovererActive(*iDiscoverer);

	// Notifiers should still be active.

	test(isDiscActive);

	// Start Active Scheduler and shut it down in 3 secs, it will launch RunL of timer to process

	// all pending notification.

	iShutdown.StartAfter(KOneSecond * 3);

	CActiveScheduler::Start();

	// Check if notifications have been processed on all drives.

	test(iStateAccessor->IsScanDirectoryComplete(*iDiscoverer));

	}

/**

The test executes by first making the test drive unmounted and

then testing for Mount and Unmount.

@SYMTestCaseID          SYSLIB-ECOM-CT-0717

@SYMTestCaseDesc	    Tests for drive mount and unmount

@SYMTestPriority 	    High

@SYMTestActions  	    First remove the drive if its already there, then test for Mount then for unmount

@SYMTestExpectedResults The test must not fail.

@SYMREQ                 REQ0000

*/

void CDiscovererTest::DriveMountUnmountTestL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0717 "));

	TInt err;

	TDriveUnit drive(EDriveC);

	//First remove the drive if its already there, then test for Mount then for unmount

	if(iStateAccessor->IsDriveMounted(*iDiscoverer, drive))

		{

		TRAP(err, iStateAccessor->DriveUnmountedL(*iDiscoverer, drive));

		TEST_OOM_ERR;

		test(err == KErrNone);

		}

	// Drive should not be present

	test(!iStateAccessor->IsDriveMounted(*iDiscoverer, drive));

	// Test Mount

	TRAP(err, iStateAccessor->DriveMountedL(*iDiscoverer, drive));

	TEST_OOM_ERR;

	test(err == KErrNone);

	// CDiscoverer->DriveMountedL/DriveUnmountedL updates both itself and

	// DiscovererObserver class for Mount/Unmount of drives. So testing for both

	test(iStateAccessor->IsDriveMounted(*iDiscoverer, drive));

	test(iDiscovererObserver->IsDriveMounted(drive));

	// Test Unmount

	TRAP(err, iStateAccessor->DriveUnmountedL(*iDiscoverer, drive));

	TEST_OOM_ERR;

	test(err == KErrNone );

	// CDiscoverer->DriveMountedL/DriveUnmountedL updates both itself and

	// DiscovererObserver class for Mount/Unmount of drives. So testing for both

	test(!iStateAccessor->IsDriveMounted(*iDiscoverer, drive));

	test(!iDiscovererObserver->IsDriveMounted(drive));

	}

/**

@SYMTestCaseID          SYSLIB-ECOM-UT-3559

@SYMTestCaseDesc	    Tests for process entry of PLUGIN3 type.

@SYMTestPriority 	    High

@SYMTestActions  	    Call CDiscoverer::ProcessEntryL().

@SYMTestExpectedResults The entry is registered successfully and no leave occurred.

@SYMEC	                EC43

*/

void CDiscovererTest::ProcessEntryPlugIn3TestL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3559 "));

	CPluginBase* entryBase = NULL;

	TInt err = KErrNone;

	//This part refers to testing of the entry containing the RSC

	_LIT(KExampleRscFileNameOnly,"EComExample12.rsc");

	TDriveName driveName1(iDriveUnit.Name());

	TParse path1;

	path1.Set(KNewResourceSearchPath(),NULL,&driveName1);

	//Creating a entry that represents the Rsc disovered during scanning of \\resource\\plugins

	TEntry rscEntry;

	rscEntry.iName = KExampleRscFileNameOnly;

	rscEntry.iType = TUidType(KNullUid,KUidInterfaceImplementationCollectionInfo,KNullUid);

	entryBase = CSecurePlugin::NewL(TheFs,rscEntry,driveName1, EFalse);

	CleanupStack::PushL(entryBase);