// 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;