diff -r 000000000000 -r e4d67989cc36 lowlevellibsandfws/pluginfw/Framework/DisableDrivesTest/t_disabledrives.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lowlevellibsandfws/pluginfw/Framework/DisableDrivesTest/t_disabledrives.cpp	Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,765 @@
+// 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
+	{
+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);
+	}