// Copyright (c) 2007-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 CDiscoverer will not discover plug-ins on C: and E:

 // if the two drives are disabled by the patchable constants.

 // 

 //

 /**

  @file

  @internalComponent

 */

 #include "RegistryData.h"

 #include "Discoverer.h"

 #include "ImplementationInformation.h"

 #include "RegistryData.h"

 #include "Registrar.h"

 #include "RegistrarObserver.h"

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

 #include "DriveInfo.h"

 #include "EComPatchDataConstantv2.h"

 #include <e32test.h>

 #include <f32file.h>

 #include <bautils.h>

 #include <startup.hrh>

 _LIT (KDataDir, "C:\\private\\10009D8F\\ECom*");

 // plugins to discover

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

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

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

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

 const TInt KOneSecond = 1000000;

 LOCAL_D RTest test(_L("Disable drives"));

 LOCAL_D RFs					TheFs;

 LOCAL_D CTrapCleanup* 		TheTrapCleanup 		= NULL;

 class CDerivedActiveScheduler;

 LOCAL_D CDerivedActiveScheduler* TheActiveScheduler	= NULL;

 LOCAL_D TInt oomStep;

 //It is used by some test methods which are called two times:

 //from normal test and from OOM test.

 static void LeaveIfErrNoMemoryL(TInt aError)

 	{

 	if(aError == KErrNoMemory)

 		{

 		User::Leave(aError);

 		}

 	}

 // Copies the Plugins to specific folder for testing purpose

 LOCAL_C void CopyPlugins()

 	{

 	TInt err=KErrNone;

 	TRAP(err, EComTestUtils::FileManCopyFileL(KNewResourceFileNameZ, KNewResourceFileNameC));

 	test(err==KErrNone);

 	TRAP(err, EComTestUtils::FileManCopyFileL(KNewDllFileNameZ, KNewDllFileNameC));

 	test(err==KErrNone);

 	}

 // Deleting plugin from the RAM for cleanup purpose

 LOCAL_C void DeleteTestPlugin(TAny* /* aUnused */)

 	{

 	TInt err=KErrNone;

 	TRAP(err, EComTestUtils::FileManDeleteFileL(KNewResourceFileNameC));

 	TRAP(err, EComTestUtils::FileManDeleteFileL(KNewDllFileNameC));

 	}

 // flags indicating a set of pre-conditions to fullfil before running

 // CDisableDrivesTest.

 enum TPreTestSetup

 	{

 	EPreTest_UnitializeCachedDriveInfo = 0x1,

 	EPreTest_EnableAllDrives = 0x2,

 	EPreTest_CopyPlugins = 0x4

 	};

 const TUint32 KStartupDiscoveryDrivesDisabledMask =

 	EPreTest_UnitializeCachedDriveInfo | EPreTest_CopyPlugins;

 const TUint32 KStartupDiscoveryDrivesEnabledMask =

 	EPreTest_EnableAllDrives | EPreTest_CopyPlugins;

 const TUint32 KRediscoveryDrivesDisabledMask =

 	EPreTest_UnitializeCachedDriveInfo;

 const TUint32 KRediscoveryDrivesEnabledMask =

 	EPreTest_EnableAllDrives;

 /**

 TRegistryData_StateAccessor class allows access to private and protected

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

 */

 class TRegistryData_StateAccessor

 	{

 public:

 	TInt FindImplementation(CRegistryData& aRegistryData,

 				const TUid aImplUid,

 				const TUid aInterfaceUid,

 				CRegistryData::CImplementationData*& aImplData) const;

 	};

 /** TRegistrar_StateAccessor class allows access to private members

 of CRegistrar. */

 class TRegistrar_StateAccessor

 	{

 	static void SetCompletedStateL(CRegistrar& aRegistrar,

 								   TStartupStateIdentifier aKnownState);

 	};

 /** TDiscoverer_StateAccessor allows manipulation of CDiscoverer

 private members. */

 class TDiscoverer_StateAccessor

 	{

 	static void SetCompletedStateL(CDiscoverer& aDiscoverer,

 								   CDiscoverer::TDiscovererState aState);

 	};

 /** TDriveInfo_StateAccessor class allows access to private members

 of CEComCachedDriveInfo. */

 class TDriveInfo_StateAccessor

 	{

 public:

 	static void ClearCachedDriveInfo();

 	static void SetDriveDisableMaskL(TUint32 aMask);

 	};

 /**

 @return		KErrNone if found otherwise KErrNotFound

 @param		aRegistryData The CRegistryData class object

 @param		aImplUid The implementation to find.

 @param		aInterfaceUid If greater than 0 the interface associated with the

 			implementation to find.

 @param		aImplData The found implementation data.

 @pre 		CRegistrar is fully constructed

 */

 TInt TRegistryData_StateAccessor::FindImplementation(CRegistryData& aRegistryData,

 												const TUid aImplUid,

 												const TUid aInterfaceUid,

 												CRegistryData::CImplementationData*& aImplData) const

 	{

 	return aRegistryData.FindImplementation(aImplUid, aInterfaceUid, aImplData);

 	}

 /** Mark the static drive info array uninitialized. Then the

 next instantiation of CEComCachedDriveInfo will need to setup

 the drive info again.

 */

 void TDriveInfo_StateAccessor::ClearCachedDriveInfo()

 	{

 	CEComCachedDriveInfo::iInitialized = EFalse;

 	}

 /** Instantiate a CEComCachedDriveInfo object with a special drive

 mask. The object is destroyed right away but the static drive info

 array is fixed to the special mask.

 @param aMask the drive disable mask to set.

 */

 void TDriveInfo_StateAccessor::SetDriveDisableMaskL(TUint32 aMask)

 	{

 	// Set this bool to false otherwise ConstructL will do nothing.

 	CEComCachedDriveInfo::iInitialized = EFalse;

 	CEComCachedDriveInfo* ptr = new (ELeave) CEComCachedDriveInfo();

 	CleanupStack::PushL(ptr);

 	ptr->ConstructL(TheFs, aMask);

 	CleanupStack::PopAndDestroy();

 	}

 /** Need a CActive to wait for CDiscoverer dir change notifiers. */

 class CSimpleTimer : public CTimer

 	{

 public:

 	inline CSimpleTimer(TInt aPriority);

 	inline void ConstructL();

 	inline void StartTimer(TTimeIntervalMicroSeconds32 aTimeInterval);

 private:

 	void RunL();

 	};

 inline CSimpleTimer::CSimpleTimer(TInt aPriority)

 	: CTimer(aPriority)

 	{

 	CActiveScheduler::Add(this);

 	}

 inline void CSimpleTimer::ConstructL()

 	{

 	CTimer::ConstructL();

 	}

 inline void CSimpleTimer::StartTimer(TTimeIntervalMicroSeconds32 aTimeInterval)

 	{

 	After(aTimeInterval);

 	}

 void CSimpleTimer::RunL()

 	{

 	CActiveScheduler::Stop();

 	}

 /** Avoid E32User::Case 47 panic in OOM test */

 class CDerivedActiveScheduler : public CActiveScheduler

 	{

 public:

 	virtual void Error(TInt aError) const;

 	};

 void CDerivedActiveScheduler::Error(TInt aError) const

 	{

 	Halt(aError);

 	}

 /**

 The implementation of the abstract Registrar Observer class,

 used for recieving notifications of registry changes.

 Stub class(for CEComServer) used for the creation of CRegistrar class object.

 CEComServer class acts as observer for CRegistrar.

 */

 class CTestRegistrarObserver : public MRegistrarObserver // codescanner::missingcclass

 	{

 public:

 	// This function is used by RegistrarObserver (i.e.CEComServer) to notify its

 	// clients(REComSession objects) that some change has happened in Registry.

 	// Here we have no clients to notify, so no implementaion.

 	void Notification( TInt /*aNotification*/ ) {}

 	};

 /**

 Test class for object CRegistrar.

 This class provides the parameters and behaviour that

 allows this class to behave normally under a test

 scenario.

 */

 class CDisableDrivesTest : public CBase

 	{

 public:

 	static CDisableDrivesTest* NewL(TBool aDrivesEnabled);

 	virtual ~CDisableDrivesTest();

 	void startupDiscoveryL();

 	void RediscoveryL();

 private:

 	CDisableDrivesTest(TBool aDrivesEnabled);

 	void ConstructL();

 	void WaitForDiscovererAOL();

 public:

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

 	CRegistrar* iRegistrar;

 	/** The instance of the State Accessor class */

 	TRegistrar_StateAccessor* iStateAccessor;

 	/** The registry data instance required to construct a CRegistrar object */

 	CRegistryData* iRegistryData;

 	/** The instance of the Registry Data State Accessor class */

 	TRegistryData_StateAccessor* iRegistryDataStateAccessor;

 	/** The instance of the observer of CRegistrar class */

 	MRegistrarObserver* iRegistrarObserver;

 	/** The destination for the data discovered during a parse */

 	CRegistryData::CDllData* iDllData;

 	/** Unique Id of the ECOM dll */

 	TUid    iDllUid;

 	/** Unique Id of an interface implementation */

 	TUid	iImplementationUid;

 	/** Unique Id of an interface */

 	TUid	iInterfaceUid;

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

 	TDriveUnit	iDriveUnit;

 	/** Ecom plugin which contains interface implementations. Used in Registration APIs.*/

 	TEntry		iDllEntry;

 	TBool		iDrivesEnabled;

 	};

 /**

 Standardised safe construction which

 leaves nothing on the cleanup stack.

 @post		CDisableDrivesTest is fully constructed and initialised.

 */

 CDisableDrivesTest* CDisableDrivesTest::NewL(TBool aDrivesEnabled)

 	{

 	CDisableDrivesTest* self = new (ELeave) CDisableDrivesTest(aDrivesEnabled);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 /**

 Standardized default c'tor

 @post		CDisableDrivesTest is fully constructed.

 */

 CDisableDrivesTest::CDisableDrivesTest(TBool aDrivesEnabled)

 :	CBase(),

 	iDriveUnit(EDriveC),

 	iDrivesEnabled(aDrivesEnabled)

 	{

 	iDllUid.iUid			= 0x101F847B; // Dlluid for Ecom plugin EComExample5.dll

 	iInterfaceUid.iUid		= 0x10009DC0; // Interface uid for interface contained in above plugin

 	iImplementationUid.iUid = 0x101f847C; // Implementaion uid for above interface

 	TUid uid1 = {0};

 	TUid uid2 = {0};

 	iDllEntry.iType = TUidType(uid1, uid2, iDllUid);//Setting Dlluid to plugin entry

 	}

 /**

 Destructor.

 @post		This object is properly destroyed.

 */

 CDisableDrivesTest::~CDisableDrivesTest()

 	{

 	delete iDllData;

 	delete iRegistrar;

 	delete iRegistryData;

 	delete iRegistrarObserver;

 	delete iStateAccessor;

 	delete iRegistryDataStateAccessor;

 	}

 /**

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

 @post		CDisableDrivesTest is fully constructed.

 */

 void CDisableDrivesTest::ConstructL()

 	{

 	CRegistryData::CDriveData* driveData=NULL;

 	iRegistrarObserver = new (ELeave) CTestRegistrarObserver;

 	iStateAccessor	   = new (ELeave) TRegistrar_StateAccessor;

 	iRegistryDataStateAccessor	   = new (ELeave) TRegistryData_StateAccessor;

 	iRegistryData	   = CRegistryData::NewL(TheFs);

 	iRegistrar		   = CRegistrar::NewL(*iRegistryData, *iRegistrarObserver, TheFs);

 	iDllData		   = CRegistryData::CDllData::NewLC(driveData);

 	CleanupStack::Pop(iDllData);

 	}

 /**

 @SYMTestCaseID		SYSLIB-ECOM-CT-3541

 @SYMTestCaseDesc 	Verify ECOM's patchdata scheme works.

 @SYMTestPriority 	High

 @SYMTestActions  	Check the value of the constant KDiscoveryDisabledDriveList.

 @SYMTestExpectedResults It should be 0x14 in hw.

 @SYMCR CR1049

 */

 void PatchableConstantTest()

 	{

 	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3541 Patch constant value "));

 	// check the patchable constant has the patched value.

 #ifdef __ARMCC__

 	test(KDiscoveryDisabledDriveList == 0x14);

 #else

 	// On emulator the constant is not patchable. Thus the RTest links

 	// with a different .cpp file.

 	test(KDiscoveryDisabledDriveList == 0x00800004);

 #endif

 	}

 /**

 @SYMTestCaseID		SYSLIB-ECOM-CT-4014

 @SYMTestCaseDesc 	Check that the patchables for custom resolver caching

     can be patched.

 @SYMTestPriority 	High

 @SYMTestActions  	Check the values of KCustomResolverCacheSize and

 	KCustomResolverCacheTimeout

 @SYMTestExpectedResults disabledrivestest.hby sets KCustomResolverCacheSize

 	to 1182 and KCustomResolverCacheTimeout to 4001182. Note that this test

 	only runs on hw.

 @SYMCR CR1182

 */

 void CR1182PatchableConstantTest()

 	{

 	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-4014 CR1182 patchable constants "));

 	// check the patchable constants have the patched values.

 #ifdef __ARMCC__

 	test(KCustomResolverCacheSize == 1182);

 	test(KCustomResolverCacheTimeout == 4001182);

 #else

 	test.Printf(_L("This test only runs in armv5."));

 #endif

 	}

 /**

 @SYMTestCaseID		SYSLIB-ECOM-CT-3542

 @SYMTestCaseDesc 	Check that CDiscoverer will not discover plug-ins in disabled drives at boot time.

 @SYMTestPriority 	High

 @SYMTestActions  	Use CRegistrar::ProcessSSAEventL to trigger boot up discovery.

 @SYMTestExpectedResults No plugins registered if C: drive is disabled. In the

 	control test, C: is enabled and the plugin is registered.

 @SYMCR CR1049

 */

 void CDisableDrivesTest::startupDiscoveryL()

 	{

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

 	// Do not scan ReadOnly internal drive in OOM. Will take an hour.

 	__UHEAP_SETFAIL(RHeap::ENone, 0);

 	iRegistrar->ProcessSSAEventL(EStartupStateCriticalStatic);

 	if (oomStep)

 		{

 		__UHEAP_SETFAIL(RHeap::EDeterministic, oomStep);

 		}

 	iRegistrar->ProcessSSAEventL(EStartupStateNonCritical);

 	CRegistryData::CImplementationData *implementationData=NULL;

 	TUid dummyUid;

 	dummyUid.iUid = 0;

 	TInt err = iRegistryDataStateAccessor->FindImplementation(*iRegistryData, iImplementationUid, dummyUid, implementationData);

 	::LeaveIfErrNoMemoryL(err);

 	if (iDrivesEnabled)

 		{

 		test(err == KErrNone);

 		}

 	else

 		{

 		test(err == KErrNotFound);

 		}

 	}

 /**

 @SYMTestCaseID		SYSLIB-ECOM-CT-3543

 @SYMTestCaseDesc 	Check that CDiscoverer will not discover plug-ins via dir

 	change notification if drive is disabled.

 @SYMTestPriority 	High

 @SYMTestActions  	After startup discovery completed, copy .rsc to

 	C:\resource\plugins and the .dll to C:\sys\bin.

 @SYMTestExpectedResults The plugin is not registered if C: is disabled. In the

 	control test, C: is enabled and the plugin is registered.

 @SYMCR CR1049

 */

 void CDisableDrivesTest::RediscoveryL()

 	{

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

 	// Do not scan ReadOnly internal drive in OOM. Will take an hour.

 	__UHEAP_SETFAIL(RHeap::ENone, 0);

 	iRegistrar->ProcessSSAEventL(EStartupStateNonCritical);

 	if (oomStep)

 		{

 		__UHEAP_SETFAIL(RHeap::EDeterministic, oomStep);

 		}

 	CopyPlugins();

 	CleanupStack::PushL(TCleanupItem(DeleteTestPlugin, NULL));

 	WaitForDiscovererAOL();

 	CRegistryData::CImplementationData *implementationData=NULL;

 	TUid dummyUid = KNullUid;

 	TInt err = iRegistryDataStateAccessor->FindImplementation(*iRegistryData, iImplementationUid, dummyUid, implementationData);

 	::LeaveIfErrNoMemoryL(err);

 	CleanupStack::PopAndDestroy(1);

 	if (iDrivesEnabled)

 		{

 		test(err == KErrNone);

 		}

 	else

 		{

 		test(err == KErrNotFound);

 		}

 	}

 void CDisableDrivesTest::WaitForDiscovererAOL()

 	{

 	// Yield priority to CDiscoverer's AO

 	CSimpleTimer* timer = new(ELeave) CSimpleTimer(CActive::EPriorityLow);

 	CleanupStack::PushL(timer);

 	timer->ConstructL();

 	timer->StartTimer(KOneSecond * 2);

 	CActiveScheduler::Start();

 	CleanupStack::PopAndDestroy(timer);

 	}

 typedef void (CDisableDrivesTest::*ClassFuncPtrL) (void);

 /**

 Wrapper function to call all test functions

 @param	aTestFuncL pointer to test function

 @param	aUseZeroMask if false, let the test use the patchable constant else

 	initialize the static drive info array with zero, i.e. enabled all.

 @param	aTestDesc test function name

 */

 LOCAL_C void DoBasicTestL(ClassFuncPtrL aTestFuncL, const TUint32 aTaskMask, const TDesC& aTestDesc)

 	{

 	test.Next(aTestDesc);

 	__UHEAP_MARK;

   	// find out the number of open handles

 	TInt startProcessHandleCount;

 	TInt startThreadHandleCount;

 	RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

 	// A series of tasks to perform before calling the test method.

 	// Delete the previous data files to ensure rediscover from scratch

 	TRAP_IGNORE(EComTestUtils::FileManDeleteFileL(KDataDir));

 	// The two flags below are mutually exclusive.

 	if (aTaskMask & EPreTest_UnitializeCachedDriveInfo)

 		{

 		TDriveInfo_StateAccessor::ClearCachedDriveInfo();

 		}

 	else if (aTaskMask & EPreTest_EnableAllDrives)

 		{

 		TDriveInfo_StateAccessor::SetDriveDisableMaskL(0);

 		}

 	if (aTaskMask & EPreTest_CopyPlugins)

 		{

 		CopyPlugins();

 		User::After(KOneSecond);

 		CleanupStack::PushL(TCleanupItem(DeleteTestPlugin, NULL));

 		}

 	// All set to start the test

 	TBool drivesEnabled = (aTaskMask & EPreTest_EnableAllDrives) != 0;

 	CDisableDrivesTest* disableDrvTest = CDisableDrivesTest::NewL(drivesEnabled);

 	CleanupStack::PushL(disableDrvTest);

 	(disableDrvTest->*aTestFuncL)();

 	CleanupStack::PopAndDestroy(disableDrvTest);

 	if (aTaskMask & EPreTest_CopyPlugins)

 		{

 		CleanupStack::PopAndDestroy(1);

 		}

 	// check that no handles have leaked

 	TInt endProcessHandleCount;

 	TInt endThreadHandleCount;

 	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

 	test(startProcessHandleCount == endProcessHandleCount);

 	test(startThreadHandleCount  == endThreadHandleCount);

 	__UHEAP_MARKEND;

 	}

 /**

 Wrapper function to call all OOM test functions

 @param aTestFuncL pointer to OOM test function

 @param aTaskMask  indicates tasks need to be done before entering

 	the OOM loop.

 @param	aTestDesc test function name

 */

 //LOCAL_C void DoOOMTestL(ClassFuncPtrL aTestFuncL,

 //						const TUint32 aTaskMask,

 //						const TDesC& aTestDesc)

 //	{

 //	test.Next(aTestDesc);

 //	TInt err(KErrNone);

 	// A series of tasks to perform before calling the test method.

 	// Delete the previous data files to ensure rediscover from scratch

 //	TRAP(err, EComTestUtils::FileManDeleteFileL(KDataDir));

 	// The two flags below are mutually exclusive.

 //	if (aTaskMask & EPreTest_UnitializeCachedDriveInfo)

 //		{

 //		TDriveInfo_StateAccessor::ClearCachedDriveInfo();

 //		}

 //	else if (aTaskMask & EPreTest_EnableAllDrives)

 //		{

 //		TDriveInfo_StateAccessor::SetDriveDisableMaskL(0);

 //		}

 //	if (aTaskMask & EPreTest_CopyPlugins)

 //		{

 //		CopyPlugins();

 //		User::After(KOneSecond);

 //		CleanupStack::PushL(TCleanupItem(DeleteTestPlugin, NULL));

 //		}

 //	TBool drivesEnabled = (aTaskMask & EPreTest_EnableAllDrives) != 0;

 //	oomStep = 0;

 //	do

 //		{

 //		__UHEAP_MARK;

   		// find out the number of open handles

 //		TInt startProcessHandleCount;

 //		TInt startThreadHandleCount;

 //		RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

 		// Need to create object here as ECom has embedded TRAPs

 		// that will fail the test if memory not available

 //		CDisableDrivesTest* disableDrvTest = CDisableDrivesTest::NewL(drivesEnabled);

 //		CleanupStack::PushL(disableDrvTest);

 		// Setting Heap failure for OOM test

 //		__UHEAP_SETFAIL(RHeap::EDeterministic, ++oomStep);

 //		TRAP(err, (disableDrvTest->*aTestFuncL)());

 //		__UHEAP_SETFAIL(RHeap::ENone, 0);

 //		CleanupStack::PopAndDestroy(disableDrvTest);

 //		disableDrvTest = NULL;

 		// check that no handles have leaked

 //		TInt endProcessHandleCount;

 //		TInt endThreadHandleCount;

 //		RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

 //		test(startProcessHandleCount == endProcessHandleCount);

 //		test(startThreadHandleCount  == endThreadHandleCount);

 //		__UHEAP_MARKEND;

 //		} while(err == KErrNoMemory);

 //	if (aTaskMask & EPreTest_CopyPlugins)

 //		{

 //		CleanupStack::PopAndDestroy(1);

 //		}

 //	test(err == KErrNone);

 //	test.Printf(_L("- server succeeded at heap failure rate of %i\n"), oomStep);

 //	}

 LOCAL_C void DoTestsL()

 	{

 	__UHEAP_MARK;

 	// Basic tests

 	PatchableConstantTest();

 	CR1182PatchableConstantTest();

 	DoBasicTestL(&CDisableDrivesTest::startupDiscoveryL,

 				KStartupDiscoveryDrivesDisabledMask,

 				_L("startupDiscoveryL scan disabled"));

 	// Control step to proof that the method is sound.

 	DoBasicTestL(&CDisableDrivesTest::startupDiscoveryL,

 				KStartupDiscoveryDrivesEnabledMask,

 				_L("startupDiscoveryL scan enabled"));

 	DoBasicTestL(&CDisableDrivesTest::RediscoveryL,

 				KRediscoveryDrivesDisabledMask,

 				_L("RediscoveryL scan disabled"));

 	// Control step to proof that the method is sound.

 	DoBasicTestL(&CDisableDrivesTest::RediscoveryL,

 				KRediscoveryDrivesEnabledMask,

 				_L("RediscoveryL scan enabled"));

 	// OOM tests are left in here as instructed by the component owner.

 	// In case we need to investigate OOM issues in the future then the

 	// SWE can follow the instructions below to run OOM test manually:

 	//

 	// CDiscoverer::CDirScanner::DoScanDriveL in discoverer.cpp ignores

 	// all errors from RFs::GetDir().

 	// Go there and manually add if (error == KErrNoMemory) User::LeaveNoMemory()

 	// Also the three RunError of the CActive in discoverer.cpp need to return

 	// KErrNoMemory instead of panic.

 	// NB: after adding the above changes, some OOM tests in t_discoverer and

 	// t_registrar will timeout in ONB (RTests are given 40 minutes to run but OOM

 	// test on discovery takes couple hours).

 	// But if these changes are manual and not submitted in perforce, then

 	// there is no effect on ONB.

 //	DoOOMTestL(&CDisableDrivesTest::startupDiscoveryL,

 //				KStartupDiscoveryDrivesDisabledMask,

 //				_L("OOM startupDiscoveryL scan disabled"));

 //	DoOOMTestL(&CDisableDrivesTest::startupDiscoveryL,

 //				KStartupDiscoveryDrivesEnabledMask,

 //				_L("OOM startupDiscoveryL scan enabled"));

 //	DoOOMTestL(&CDisableDrivesTest::RediscoveryL,

 //				KRediscoveryDrivesDisabledMask,

 //				_L("OOM RediscoveryL scan disabled"));

 	// Control step to proof that the method is sound.

 //	DoOOMTestL(&CDisableDrivesTest::RediscoveryL,

 //				KRediscoveryDrivesEnabledMask,

 //				_L("OOM RediscoveryL scan enabled"));

 	__UHEAP_MARKEND;

 	}

 //Initialise the Active Scheduler

 LOCAL_C void SetupL()

 	{

 	// Construct and install the Active Scheduler. The Active Schedular is needed

 	// by components used by this test as they are ActiveObjects.

 	TheActiveScheduler = new(ELeave)CDerivedActiveScheduler;

 	CActiveScheduler::Install(TheActiveScheduler);

 	}

 GLDEF_C TInt E32Main()

 	{

 	__UHEAP_MARK;

 	test.Printf(_L("\n"));

 	test.Title();

 	test.Start( _L("Disable scanning on selected drives via patchable constant") );

 	TheTrapCleanup = CTrapCleanup::New();

 	// Connect the file server instance

 	User::LeaveIfError(TheFs.Connect());

 	TRAPD(err, SetupL());

 	test(err == KErrNone);

 	// Call the main tests

 	TRAP(err, DoTestsL());

 	test(err == KErrNone);

 	delete TheActiveScheduler;

 	delete TheTrapCleanup;

 	TheFs.Close();

 	test.End();

 	test.Close();

 	__UHEAP_MARKEND;

 	return (KErrNone);

 	}