sl@0: // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: // This file contains test classes and their implementations
sl@0: // to test production class CCustomResolverCache.
sl@0: // 
sl@0: //
sl@0: 
sl@0: #include <e32test.h>
sl@0: #include <f32file.h>
sl@0: #include <hal.h>
sl@0: #include <bautils.h>
sl@0: #include <babitflags.h>
sl@0: #include <babackup.h>
sl@0: #include <startup.hrh>
sl@0: #include <ecom/resolver.h>
sl@0: #include "EComErrorCodes.h"
sl@0: #include "EComUidCodes.h"
sl@0: #include "ImplementationInformation.h"
sl@0: #include "RegistryData.h"
sl@0: #include "Registrar.h"
sl@0: #include "RegistrarObserver.h"
sl@0: #include "../EcomTestUtils/EcomTestUtils.h"
sl@0: #include <swi/swispubsubdefs.h>
sl@0: #include "../EcomTestUtils/TPropertyManager.h"
sl@0: #include "EComPatchDataConstantv2.h"
sl@0: #include "RegistryResolveTransaction.h"  // ecom3 code
sl@0: #include "callback.h"
sl@0: #include "resolvercache.h"
sl@0: #include "EComServer.h"
sl@0: 
sl@0: 
sl@0: const TInt KOneSecond = 1000000;
sl@0: const TInt KHalfSecond = KOneSecond / 2;
sl@0: // Use this timeout to wait for events occuring within a few seconds.
sl@0: const TInt KIndefiniteWait = KOneSecond * 20;
sl@0: 
sl@0: LOCAL_D RTest test(_L("t_resolvercache.exe"));
sl@0: 
sl@0: LOCAL_D RFs					TheFs;
sl@0: LOCAL_D CTrapCleanup* 		TheTrapCleanup 		= NULL;
sl@0: class CDerivedActiveScheduler;
sl@0: LOCAL_D CDerivedActiveScheduler* TheActiveScheduler	= NULL;
sl@0: 
sl@0: 
sl@0: // custom resolvers available for testing.
sl@0: // 200126cd, A0001346 and A0001347 are allocated outside the
sl@0: // ECOM Uid Allocations.doc
sl@0: const TUid KDummyResolverUid2  = {0xA0001346};
sl@0: const TUid KDummyResolverUid3  = {0xA0001347};
sl@0: const TUid KExampleResolverUid = {0x10009DD0};
sl@0: const TUid KMyResolverUid      = {0x10009E12};
sl@0: const TUid KDummyResolverUid1  = {0x200126CD};
sl@0: 
sl@0: // The custom resolver in RAMOnly dir
sl@0: _LIT(KDummyRscInC, "c:\\resource\\plugins\\dummycustomresolver1.rsc");
sl@0: _LIT(KDummyDllInC, "c:\\sys\\bin\\dummycustomresolver1.dll");
sl@0: 
sl@0: _LIT(KDummyRscInZ, "z:\\ramonly\\dummycustomresolver1.rsc");
sl@0: _LIT(KDummyDllInZ, "z:\\ramonly\\dummycustomresolver1.dll");
sl@0: 
sl@0: // This pair is to upgrade a resolver DLL.
sl@0: // NB: to supersede a Z: drive plugin, the C: DLL must have the
sl@0: // same name as the one in z: drive. Hence the '2' is dropped.
sl@0: _LIT(KDllUpgradeInZ, "z:\\ramonly\\cachedcustomresolver2.dll");
sl@0: _LIT(KDllUpgradeInC, "c:\\sys\\bin\\cachedcustomresolver.dll");
sl@0: 
sl@0: _LIT(KRscUpgradeInZ, "z:\\ramonly\\cachedcustomresolver2.rsc");
sl@0: _LIT(KRscUpgradeInC, "c:\\resource\\plugins\\cachedcustomresolver.rsc");
sl@0: 
sl@0: /** User::AfterHighRes is not a reliable mechanism to wait
sl@0: for async events. Especially when we have 4 different timers
sl@0: firing within a span of 4 s. Hence this harness intercepts
sl@0: and inserts callbacks in the notification sources and set
sl@0: the following flag to indicate what event has occured. */
sl@0: LOCAL_D TBitFlags32 AsyncEvents = 0;
sl@0: 
sl@0: /** enum to identify different async events */
sl@0: enum TAsyncEventId
sl@0: 	{
sl@0: 	EAsyncEvent_Unknown = 0,
sl@0: 	EAsyncEvent_ImplUpgrade,
sl@0: 	EAsyncEvent_SwiStart,
sl@0: 	EAsyncEvent_SwiEnd,
sl@0: 	EAsyncEvent_BurStart,
sl@0: 	EAsyncEvent_BurEnd,
sl@0: 	EAsyncEvent_CacheTimer,
sl@0: 	EAsyncEvent_HaltTimer
sl@0: 	};
sl@0: 
sl@0: //
sl@0: // maps callback data to enum TAsyncEventId.
sl@0: LOCAL_C TAsyncEventId CallbackDataToEventId(TInt aEvent, TAny* aData)
sl@0: 	{
sl@0: 	TAsyncEventId ret = EAsyncEvent_Unknown;
sl@0: 	TCallBackState* state = static_cast<TCallBackState*>(aData);
sl@0: 	if (aEvent == ECallBackId_SwiEvent)
sl@0: 		{
sl@0: 		if (*state == ECallBackState_EventStart)
sl@0: 			{
sl@0: 			ret = EAsyncEvent_SwiStart;
sl@0: 			}
sl@0: 		else // treat all unexpected states as SWI end!
sl@0: 			{
sl@0: 			ret = EAsyncEvent_SwiEnd;
sl@0: 			}
sl@0: 		}
sl@0: 	else if (aEvent == ECallBackId_BurEvent)
sl@0: 		{
sl@0: 		if (*state == ECallBackState_EventStart)
sl@0: 			{
sl@0: 			ret = EAsyncEvent_BurStart;
sl@0: 			}
sl@0: 		else // treat all unexpected states as BUR finish!
sl@0: 			{
sl@0: 			ret = EAsyncEvent_BurEnd;
sl@0: 			}
sl@0: 		}
sl@0: 	else if (aEvent == ECallBackId_ImplUpgrade)
sl@0: 		{
sl@0: 		ret = EAsyncEvent_ImplUpgrade;
sl@0: 		}
sl@0: 	return ret;
sl@0: 	}
sl@0: 
sl@0: // beginningOfTest is set when this harness is run.
sl@0: LOCAL_D TTime beginningOfTest;
sl@0: LOCAL_C void WaitForLazyUnloadingL()
sl@0: 	{
sl@0: 	TTime now;
sl@0: 	now.UniversalTime();
sl@0: 
sl@0: 	TTimeIntervalSeconds n;
sl@0: 	User::LeaveIfError(now.SecondsFrom(beginningOfTest, n));
sl@0: 	const TInt KLazyDllUnloadPeriod =  150; // actual is 2 minutes
sl@0: 	TInt secondsToWait = KLazyDllUnloadPeriod - n.Int();
sl@0: 	test.Printf(_L("Amount to wait for lazy unload is %d seconds.\n"), secondsToWait);
sl@0: 	if (secondsToWait > 0)
sl@0: 		{
sl@0: 		User::After(KOneSecond * secondsToWait);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: // Copies the Plugins to specific folder for testing purpose
sl@0: LOCAL_C void CopyPluginsL()
sl@0: 	{
sl@0: 	EComTestUtils::FileManCopyFileL(KDummyRscInZ, KDummyRscInC);
sl@0: 	EComTestUtils::FileManCopyFileL(KDummyDllInZ, KDummyDllInC);
sl@0: 	}
sl@0: 
sl@0: // Deleting plugin from the RAM for cleanup purpose
sl@0: LOCAL_C void DeleteTestPlugin()
sl@0: 	{
sl@0: 	TRAP_IGNORE(EComTestUtils::FileManDeleteFileL(KDummyRscInC));
sl@0: 	TRAP_IGNORE(EComTestUtils::FileManDeleteFileL(KDummyDllInC));
sl@0: 
sl@0: 	TRAP_IGNORE(EComTestUtils::FileManDeleteFileL(KRscUpgradeInC));
sl@0: 	TRAP_IGNORE(EComTestUtils::FileManDeleteFileL(KDllUpgradeInC));
sl@0: 	}
sl@0: 
sl@0: // utility to help cast TTimeIntervalMicroSeconds to TInt
sl@0: LOCAL_C TInt CalcElapsedMicroseconds(const TTime& aStart)
sl@0: 	{
sl@0: 	TTime now;
sl@0: 	now.UniversalTime();
sl@0: 	TTimeIntervalMicroSeconds timediff = now.MicroSecondsFrom(aStart);
sl@0: 	return I64LOW( timediff.Int64() );
sl@0: 	}
sl@0: 
sl@0: /** Need a CActive to wait for various change notifications. */
sl@0: class CHaltTimer : public CTimer
sl@0: 	{
sl@0: public:
sl@0: 	CHaltTimer(TInt aPriority);
sl@0: 	~CHaltTimer();
sl@0: 	void ConstructL();
sl@0: 	void StartTimer(TInt aTimeInterval);
sl@0: 
sl@0: private:
sl@0: 	void RunL();
sl@0: 	};
sl@0: 
sl@0: CHaltTimer::CHaltTimer(TInt aPriority)
sl@0: 	: CTimer(aPriority)
sl@0: 	{
sl@0: 	CActiveScheduler::Add(this);
sl@0: 	}
sl@0: 
sl@0: CHaltTimer::~CHaltTimer()
sl@0: 	{
sl@0: 	Cancel();
sl@0: 	}
sl@0: 
sl@0: void CHaltTimer::ConstructL()
sl@0: 	{
sl@0: 	CTimer::ConstructL();
sl@0: 	}
sl@0: 
sl@0: void CHaltTimer::StartTimer(TInt aTimeInterval)
sl@0: 	{
sl@0: 	After(aTimeInterval);
sl@0: 	}
sl@0: 
sl@0: void CHaltTimer::RunL()
sl@0: 	{
sl@0: 	AsyncEvents.Set(EAsyncEvent_HaltTimer);
sl@0: 	CActiveScheduler::Stop();
sl@0: 	}
sl@0: 
sl@0: /** Avoid E32User::Case 47 panic in OOM test */
sl@0: class CDerivedActiveScheduler : public CActiveScheduler
sl@0: 	{
sl@0: public:
sl@0: 	virtual void Error(TInt aError) const;
sl@0: 	};
sl@0: 
sl@0: void CDerivedActiveScheduler::Error(TInt aError) const
sl@0: 	{
sl@0: 	Halt(aError);
sl@0: 	}
sl@0: 
sl@0: /** friend class to access private members of CEComServer */
sl@0: class TEComServer_StateAccessor
sl@0: 	{
sl@0: public:
sl@0: 	static void InterceptCallbacks(CEComServer& aEComServer, TCallBackWithArg aCb);
sl@0: 	static CCustomResolverCache* GetResolverCache(CEComServer& aEComServer);
sl@0: 	};
sl@0: 
sl@0: /** Test class for object CCustomResolverCache.
sl@0: */
sl@0: class CCustomResolverCacheTest : public CBase
sl@0: 	{
sl@0: public:
sl@0: 	typedef void (CCustomResolverCacheTest::*ClassFuncPtrL) (void);
sl@0: 
sl@0: 	virtual ~CCustomResolverCacheTest();
sl@0: 	static CCustomResolverCacheTest* NewL();
sl@0: 	static void RunAllTestsL();
sl@0: 	static TInt InterceptCacheMgrCallback(TAny* aObj, TInt aEvent, TAny* aData);
sl@0: 	static TInt CacheTimeoutCallback(TAny* aObj, TInt aEvent, TAny* aData);
sl@0: 
sl@0: private:
sl@0: 	CCustomResolverCacheTest();
sl@0: 	void ConstructL();
sl@0: 
sl@0: 	static void DoBasicTestL(ClassFuncPtrL aTestFunc);
sl@0: 	static void DoOOMTestL(ClassFuncPtrL aTestFunc);
sl@0: 
sl@0: 	// Test cases
sl@0: 	void TestUpgradingCachedResolverL();
sl@0: 	void TestDeletingCachedResolverL();
sl@0: 
sl@0: 	void TestCacheQueueFullPattern1L();
sl@0: 	void TestCacheQueueFullPattern2L();
sl@0: 	void TestCacheQueueFullPattern3L();
sl@0: 	void DoQueueFullTestL(const RArray<TUid>& aResolverList);
sl@0: 
sl@0: 	void TestCounterWrapAroundL();
sl@0: 	void TestCacheTimerAccuracyL();
sl@0: 	void TestTimestampUpdateOnCacheHitL();
sl@0: 	void TestSWIDisableRwResolverCachingL();
sl@0: 	void TestBurDisableRwResolverCachingL();
sl@0: 	void TestClockChangeHasNoEffectOnCacheTimeoutL();
sl@0: 	void TestCacheSizeZeroL();
sl@0: 	void TestCacheTimeoutZeroL();
sl@0: 	void TestResolverWithBadProxyTable();
sl@0: 
sl@0: 	// utilities
sl@0: 	TBool UseResolverCheckVersionL(TUid aResolverUid,
sl@0: 								   TInt aVersion = 0);
sl@0: 	void YieldToOtherCActive(TInt aMicroSeconds);
sl@0: 	void WaitAsyncL(TInt aNumSeconds);
sl@0: 	TBool WaitForEvict(TUid aResolverUid);
sl@0: 
sl@0: 	// access private data of CCustomResolverCache
sl@0: 	TInt CacheSize();
sl@0: 	TBool HasResolverUid(TUid aUid);
sl@0: 	TBool QueueIsSorted();
sl@0: 	inline CCustomResolverCache* ResolverCache();
sl@0: 
sl@0: private:
sl@0: 	/** need a CActive to wait for other async events */
sl@0: 	CHaltTimer* iHaltTimer;
sl@0: 
sl@0: 	CEComServer* iEComServer;
sl@0: 	};
sl@0: 
sl@0: //==============================================
sl@0: // class TEComServer_StateAccessor
sl@0: //==============================================
sl@0: void TEComServer_StateAccessor::InterceptCallbacks(CEComServer& aEComServer,
sl@0: 												   TCallBackWithArg aCb)
sl@0: 	{
sl@0: 	aEComServer.iRegistrar->InstallSwiEventCallBack(aCb);
sl@0: 	aEComServer.iRegistrar->InstallBurEventCallBack(aCb);
sl@0: 	aEComServer.iRegistryData->SetImplUpgradeCallBack(aCb);
sl@0: 	}
sl@0: 
sl@0: CCustomResolverCache*
sl@0: TEComServer_StateAccessor::GetResolverCache(CEComServer& aEComServer)
sl@0: 	{
sl@0: 	return aEComServer.iResolverCache;
sl@0: 	}
sl@0: 
sl@0: //==============================================
sl@0: // class CCustomResolverCacheTest
sl@0: //==============================================
sl@0: 
sl@0: /** CCustomResolverCacheTest constructor */
sl@0: CCustomResolverCacheTest::CCustomResolverCacheTest()
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: /** CCustomResolverCacheTest destructor. */
sl@0: CCustomResolverCacheTest::~CCustomResolverCacheTest()
sl@0: 	{
sl@0: 	delete iEComServer;
sl@0: 	delete iHaltTimer;
sl@0: 	}
sl@0: 
sl@0: /** static factory method to instantiate CCustomResolverCacheTest object.
sl@0: */
sl@0: CCustomResolverCacheTest* CCustomResolverCacheTest::NewL()
sl@0: 	{
sl@0: 	CCustomResolverCacheTest* self = new(ELeave) CCustomResolverCacheTest;
sl@0: 	CleanupStack::PushL(self);
sl@0: 	self->ConstructL();
sl@0: 	CleanupStack::Pop(self);
sl@0: 	return self;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Standardized 2nd phase of two phase construction.
sl@0: */
sl@0: void CCustomResolverCacheTest::ConstructL()
sl@0: 	{
sl@0: 	iHaltTimer = new(ELeave) CHaltTimer(CActive::EPriorityIdle);
sl@0: 	iHaltTimer->ConstructL();
sl@0: 
sl@0: 	iEComServer = CEComServer::NewLC();
sl@0: 	CleanupStack::Pop(iEComServer);
sl@0: 
sl@0: 	TCallBackWithArg interceptorCB(&InterceptCacheMgrCallback, this);
sl@0: 	TEComServer_StateAccessor::InterceptCallbacks(*iEComServer, interceptorCB);
sl@0: 
sl@0: 	TCallBackWithArg cacheTimerCb(&CacheTimeoutCallback, this);
sl@0: 	ResolverCache()->iTimerExpireCB = cacheTimerCb;
sl@0: 	}
sl@0: 
sl@0: /** util to fetch CEComServer::iResolverCache */
sl@0: inline CCustomResolverCache* CCustomResolverCacheTest::ResolverCache()
sl@0: 	{
sl@0: 	return TEComServer_StateAccessor::GetResolverCache(*iEComServer);
sl@0: 	}
sl@0: 
sl@0: /** the test harness install this callback with ECOM server objects
sl@0: to intercept async events. This callback will relay the original
sl@0: call to CEComServer, then raise a flag to indicate what
sl@0: event has occurred.
sl@0: @param aObj pointer to the CCustomResolverCacheTest object
sl@0: @param aEvent ID of event triggering the callback
sl@0: @param aData  pointer to some data associated with the event.
sl@0: @return Always KErrNone. It is ignored.
sl@0: */
sl@0: TInt CCustomResolverCacheTest::InterceptCacheMgrCallback(TAny* aObj,
sl@0: 														 TInt aEvent,
sl@0: 														 TAny* aData)
sl@0: 	{
sl@0: 	CCustomResolverCacheTest* self = static_cast<CCustomResolverCacheTest*>(aObj);
sl@0: 	// Pass the event along to let CEComServer does its thing.
sl@0: 	CEComServer::NotifyEvents(self->iEComServer, aEvent, aData);
sl@0: 
sl@0: 	if (self->iHaltTimer->IsActive())
sl@0: 		{
sl@0: 		TAsyncEventId event = CallbackDataToEventId(aEvent, aData);
sl@0: 		AsyncEvents.Set(event);
sl@0: 
sl@0: 		self->iHaltTimer->Cancel();
sl@0: 		CActiveScheduler::Stop();
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		// BUR and SWI unit test cases just call the notifier
sl@0: 		// directly. So CHaltTimer is not running.
sl@0: 		test.Printf(_L("CacheTest: caught async event %d when timer not running\n"), aEvent);
sl@0: 		}
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: /** A callback installed in cache mgr. Whenever the cache timer expires
sl@0: this callback is invoked by CCustomResolverCache
sl@0: @param aObj pointer to CCustomResolverCacheTest
sl@0: @return Always KErrNone. It is ignored.
sl@0: */
sl@0: TInt CCustomResolverCacheTest::CacheTimeoutCallback(TAny* aObj, TInt, TAny*)
sl@0: 	{
sl@0: 	AsyncEvents.Set(EAsyncEvent_CacheTimer);
sl@0: 
sl@0: 	CCustomResolverCacheTest* self = static_cast<CCustomResolverCacheTest*>(aObj);
sl@0: 	self->iHaltTimer->Cancel();
sl@0: 	CActiveScheduler::Stop();
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: /** Wrapper function to run normal mode (non-OOM) test
sl@0: */
sl@0: void CCustomResolverCacheTest::DoBasicTestL(ClassFuncPtrL aTestFunc)
sl@0: 	{
sl@0: 	__UHEAP_MARK;
sl@0: 	TInt startProcessHandleCount;
sl@0: 	TInt startThreadHandleCount;
sl@0: 	RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
sl@0: 
sl@0: 	CCustomResolverCacheTest* p = CCustomResolverCacheTest::NewL();
sl@0: 	(p->*aTestFunc)();
sl@0: 	delete p;
sl@0: 
sl@0: 	// check that no handles have leaked
sl@0: 	TInt endProcessHandleCount;
sl@0: 	TInt endThreadHandleCount;
sl@0: 	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
sl@0: 
sl@0: 	test(startProcessHandleCount == endProcessHandleCount);
sl@0: 	test(startThreadHandleCount  == endThreadHandleCount);
sl@0: 	__UHEAP_MARKEND;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID		SYSLIB-ECOM-UT-4020
sl@0: @SYMTestCaseDesc 	Verify no memory leak in CCustomResolverCache.
sl@0: @SYMTestPriority 	Critical
sl@0: @SYMTestActions  	Run UT-4015, UT-4016 and UT-4017 under OOM.
sl@0: @SYMTestExpectedResults No memory leak, no handle leak.
sl@0: @SYMCR CR1182
sl@0: */
sl@0: void CCustomResolverCacheTest::DoOOMTestL(ClassFuncPtrL aTestFunc)
sl@0: 	{
sl@0: 	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4020 "));
sl@0: 	__UHEAP_MARK;
sl@0: 	TInt startProcessHandleCount;
sl@0: 	TInt startThreadHandleCount;
sl@0: 	RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
sl@0: 	TInt err(KErrNone);
sl@0: 	TInt oomStep = 0;
sl@0: 
sl@0: 	do {
sl@0: 		// Instantiation of CCustomResolverCacheTest involves building
sl@0: 		// the registry. It will take couple hours under OOM. Hence do it
sl@0: 		// outside __UHEAP_SETFAIL.
sl@0: 		CCustomResolverCacheTest* p = CCustomResolverCacheTest::NewL();
sl@0: 
sl@0: 		__UHEAP_SETFAIL(RHeap::EDeterministic, ++oomStep);
sl@0: 		TRAP(err, (p->*aTestFunc)());
sl@0: 		__UHEAP_SETFAIL(RHeap::ENone, 0);
sl@0: 
sl@0: 		delete p;
sl@0: 	} while (err == KErrNoMemory);
sl@0: 
sl@0: 	test(err == KErrNone);
sl@0: 	test.Printf(_L("OOM succeeded at heap failure rate %d\n"), oomStep);
sl@0: 
sl@0: 	// check that no handles have leaked
sl@0: 	TInt endProcessHandleCount;
sl@0: 	TInt endThreadHandleCount;
sl@0: 	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
sl@0: 
sl@0: 	test(startProcessHandleCount == endProcessHandleCount);
sl@0: 	test(startThreadHandleCount  == endThreadHandleCount);
sl@0: 	__UHEAP_MARKEND;
sl@0: 	}
sl@0: 
sl@0: /** helper, ecom3 code
sl@0: Issue a list request to add resolver to cache and check if
sl@0: the registry has the expected version of the resolver.
sl@0: @param aResolverUid the custom resolver to create
sl@0: @param aVersion the expected version of the custom resolver. Check is skipped
sl@0:   if aVersion is zero.
sl@0: */
sl@0: TBool CCustomResolverCacheTest::UseResolverCheckVersionL(TUid aResolverUid,
sl@0: 														TInt aVersion)
sl@0: 	{
sl@0: 	TEComResolverParams resolverparams;
sl@0: 	_LIT8(KDummyData,"dummy");
sl@0: 	resolverparams.SetDataType(KDummyData);
sl@0: 
sl@0: 	TClientRequest clientReq;
sl@0: 	RArray<TUid> extendedInterfaces;
sl@0: 	RImplInfoArray* infoArray = iEComServer->ListImplementationsL(
sl@0: 		KCustomResolverInterfaceUid, resolverparams, aResolverUid,
sl@0: 		extendedInterfaces, clientReq);
sl@0: 
sl@0: 	TBool ret = (aVersion == 0);
sl@0: 
sl@0: 	// infoArray not pushed because there are no leave in this search.
sl@0: 	for (TInt i = 0; !ret && i < infoArray->Count(); i++)
sl@0: 		{
sl@0: 		const CImplementationInformation* impl = (*infoArray)[i];
sl@0: 		if (impl->ImplementationUid() == aResolverUid && impl->Version() == aVersion)
sl@0: 			{
sl@0: 			ret = ETrue;
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	infoArray->Reset();
sl@0: 	delete infoArray;
sl@0: 
sl@0: 	return ret;
sl@0: 	}
sl@0: 
sl@0: /** utility to let other CActive s to run. */
sl@0: void CCustomResolverCacheTest::YieldToOtherCActive(TInt aMicroSeconds)
sl@0: 	{
sl@0: 	iHaltTimer->StartTimer(aMicroSeconds);
sl@0: 	CActiveScheduler::Start();
sl@0: 	}
sl@0: 
sl@0: /** Call YieldToOtherCActive as many times as needed
sl@0: until aNumSeconds is reached. */
sl@0: void CCustomResolverCacheTest::WaitAsyncL(TInt aNumSeconds)
sl@0: 	{
sl@0: 	TTime start, now;
sl@0: 	start.UniversalTime();
sl@0: 	TTimeIntervalSeconds elapsed;
sl@0: 
sl@0: 	for (elapsed = 0; elapsed.Int() < aNumSeconds; )
sl@0: 		{
sl@0: 		AsyncEvents.ClearAll();
sl@0: 		TInt seconds = (aNumSeconds - elapsed.Int());
sl@0: 		YieldToOtherCActive(KOneSecond * seconds);
sl@0: 		now.UniversalTime();
sl@0: 		User::LeaveIfError(now.SecondsFrom(start, elapsed));
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: This method is used in the situation that cache timer is already
sl@0: started when we load the given resolver. Then when cache timer
sl@0: expires, the resolver is not ripe to be evicted. Have to wait a
sl@0: second time.
sl@0: @param aResolverUid the Resolver to wait for evict.
sl@0: @return ETrue means the resolver is evicted correctly.
sl@0: 		EFalse means error, i.e. test fail.
sl@0: */
sl@0: TBool CCustomResolverCacheTest::WaitForEvict(TUid aResolverUid)
sl@0: 	{
sl@0: 	TBool ret = EFalse;
sl@0: 	// No point of waiting for 20s for cache timeout.
sl@0: 	TInt waitMicroSec = KCustomResolverCacheTimeout + KOneSecond;
sl@0: 	for (TInt i = 0; (i < 2) && !ret; i++)
sl@0: 		{
sl@0: 		AsyncEvents.ClearAll();
sl@0: 		YieldToOtherCActive(waitMicroSec);
sl@0: 		// Check which async event has stopped the activescheduler
sl@0: 		test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );
sl@0: 		ret = ! HasResolverUid(aResolverUid);
sl@0: 		}
sl@0: 	return ret;
sl@0: 	}
sl@0: 
sl@0: //==========================================================
sl@0: // utilities to access internal data of CCustomResolverCache.
sl@0: // This is possible because CCustomResolverCacheTest is a friend.
sl@0: //===========================================================
sl@0: 
sl@0: TInt CCustomResolverCacheTest::CacheSize()
sl@0: 	{
sl@0: 	return ResolverCache()->iResolvers.Count();
sl@0: 	}
sl@0: 
sl@0: TBool CCustomResolverCacheTest::HasResolverUid(TUid aUid)
sl@0: 	{
sl@0: 	for (TInt i = 0; i < ResolverCache()->iResolvers.Count(); i++)
sl@0: 		{
sl@0: 		if (ResolverCache()->iResolvers[i].iResolverUid == aUid)
sl@0: 			{
sl@0: 			return ETrue;
sl@0: 			}
sl@0: 		}
sl@0:     return EFalse;
sl@0: 	}
sl@0: 
sl@0: TBool CCustomResolverCacheTest::QueueIsSorted()
sl@0: 	{
sl@0: 	CCustomResolverCache* theResolverCache = ResolverCache();
sl@0: 	for (TInt i = 1; i < theResolverCache->iResolvers.Count(); i++)
sl@0: 		{
sl@0: 		if (theResolverCache->iResolvers[i-1].iResolverUid.iUid >=
sl@0: 			theResolverCache->iResolvers[i].iResolverUid.iUid)
sl@0: 			{
sl@0: 			test.Printf(_L("Sort error: i-1 %d, 0x%8X, 0x%8X\n"), i-1,
sl@0: 				theResolverCache->iResolvers[i-1].iResolverUid.iUid,
sl@0: 				theResolverCache->iResolvers[i].iResolverUid.iUid	);
sl@0: 			return EFalse;
sl@0: 			}
sl@0: 		}
sl@0:     return ETrue;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID		SYSLIB-ECOM-CT-4012
sl@0: @SYMTestCaseDesc 	If a cached resolver is superseded by a new version, it
sl@0: 	is evicted from cache.
sl@0: @SYMTestPriority 	High
sl@0: @SYMTestActions  	1. Use a custom resolver to get it in cache.
sl@0: 	2. copy the upgrade version of the resolver to C: and wait for
sl@0: 	   its discovery.
sl@0: @SYMTestExpectedResults 1. a/. The resolver is the base version.
sl@0:        b/. It is added in the cache.
sl@0: 	2. a/. Cache mgr receives upgrade notification (from CRegistryData).
sl@0: 	   b/. The resolver entry disappears from cache and the cache timer is
sl@0: 	       still running.
sl@0: @SYMCR CR1182
sl@0: */
sl@0: void CCustomResolverCacheTest::TestUpgradingCachedResolverL()
sl@0: 	{
sl@0: 	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-4012 "));
sl@0: 	// get the customer resolver in cache. It should be version 1.
sl@0: 	test (UseResolverCheckVersionL(KMyResolverUid, 1));
sl@0: 	// Check that KMyResolverUid is added to cache.
sl@0: 	test(HasResolverUid(KMyResolverUid));
sl@0: 
sl@0: 	// Need an extra item in cache to get Bullseye to check off
sl@0: 	// a conditional. It is not an active ingredient of this test.
sl@0: 	UseResolverCheckVersionL(KDummyResolverUid1, 0);
sl@0: 
sl@0: 	// Copy the upgrade to C: drive
sl@0: 	EComTestUtils::FileManCopyFileL(KRscUpgradeInZ, KRscUpgradeInC);
sl@0: 	EComTestUtils::FileManCopyFileL(KDllUpgradeInZ, KDllUpgradeInC);
sl@0: 
sl@0: 	// Let CDiscoverer discover the resource file.
sl@0: 	AsyncEvents.ClearAll();
sl@0: 	YieldToOtherCActive(KIndefiniteWait);  // 20 s
sl@0: 
sl@0: 	// Check which async event has stopped the activescheduler
sl@0: 	test( AsyncEvents.IsSet(EAsyncEvent_ImplUpgrade) );
sl@0: 
sl@0: 	// And the cache entry should be gone.
sl@0: 	test(! HasResolverUid(KMyResolverUid));
sl@0: 
sl@0: 	// cleanup. NB: we never loaded the DLL in C: drive so
sl@0: 	// no need to worry about lazy dll unloading.
sl@0: 	EComTestUtils::FileManDeleteFileL(KRscUpgradeInC);
sl@0: 	EComTestUtils::FileManDeleteFileL(KDllUpgradeInC);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID		SYSLIB-ECOM-CT-4013
sl@0: @SYMTestCaseDesc 	Verify a cached DLL cannot be deleted until it
sl@0: 	is removed from cache. This test serves as a sanity check that
sl@0: 	ECOM does need these notifications to trigger unloading DLL
sl@0: 	on SWI and BUR events.
sl@0: @SYMTestPriority 	Medium
sl@0: @SYMTestActions  	1. Use a RW drive resolver to get it in cache.
sl@0: 	2. Try to delete the DLL within default cache timeout period.
sl@0:     3. Try again after it is evicted from cache.
sl@0: @SYMTestExpectedResults 1. The resolver is added in cache.
sl@0: 	2. Get KErrAccessDenied error.
sl@0: 	3. The delete is either KErrNone or KErrNotFound because in step 2
sl@0: 	   even though the return code is -21, the file may be actually gone.
sl@0: @SYMCR CR1182
sl@0: */
sl@0: void CCustomResolverCacheTest::TestDeletingCachedResolverL()
sl@0: 	{
sl@0: 	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-4013 "));
sl@0: 	// NB: lazy Dll unloading interferes with this test.
sl@0: 	// Best to run this test at the end.
sl@0: 	WaitForLazyUnloadingL();
sl@0: 
sl@0: 	// There is only 1 version of 200126CD. No need to check version.
sl@0: 	// So ignore the return code.
sl@0: 	UseResolverCheckVersionL(KDummyResolverUid1, 0);
sl@0: 
sl@0: 	// Check that it is added to cache.
sl@0: 	test( HasResolverUid(KDummyResolverUid1) );
sl@0: 
sl@0: 	TInt err(KErrNone);
sl@0: 	TRAP(err, EComTestUtils::FileManDeleteFileL(KDummyDllInC));
sl@0: 
sl@0: #ifndef __WINSCW__
sl@0: 	// On hw you can delete the DLL while it is loaded.
sl@0: 	if (err == KErrNone)
sl@0: 		{
sl@0: 		test.Printf(_L("Delete test: RFs allows deletion of loaded DLL on hw. Test not run.\n"));
sl@0: 		EComTestUtils::FileManCopyFileL(KDummyDllInZ, KDummyDllInC);
sl@0: 		return;
sl@0: 		}
sl@0: #endif
sl@0: 
sl@0: 	test(err == KErrAccessDenied);
sl@0: 
sl@0: 	// Wait for its eviction after cache timeout.
sl@0: 	AsyncEvents.ClearAll();
sl@0: 	YieldToOtherCActive(KIndefiniteWait);  // 20 s
sl@0: 
sl@0: 	// Check which async event has stopped the activescheduler
sl@0: 	test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );
sl@0: 	// Check the resolver is evicted
sl@0: 	test( !HasResolverUid(KDummyResolverUid1) );
sl@0: 
sl@0: 	TRAP(err, EComTestUtils::FileManDeleteFileL(KDummyDllInC));
sl@0: 	test(err == KErrNone || err == KErrNotFound);
sl@0: 
sl@0: 	// restore the file
sl@0: 	EComTestUtils::FileManCopyFileL(KDummyDllInZ, KDummyDllInC);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID		SYSLIB-ECOM-UT-4015
sl@0: @SYMTestCaseDesc 	Verify cache queue does not grow beyond the max
sl@0: 	queue size. Verify when a resolver is added to a full cache,
sl@0: 	the one to evict is the least recently used.
sl@0: 
sl@0: 	There are 3 versions of this test. In Pattern1, the LRU entry
sl@0: 	has UID value which is the smallest of the 5 resolvers.
sl@0: 	In pattern 2, UID of the LRU is greatest. In pattern 3, UID of the
sl@0: 	LRU is the second smallest.
sl@0: @SYMTestPriority 	High
sl@0: @SYMTestActions  	1. Use 4 different resolvers to fill up the cache.
sl@0: 	2. Use a fifth one to bump off the least recently used entry.
sl@0:     Run these two steps with the LRU entry in different positions in the
sl@0: 	queue, i.e. it is first, second, and last in the queue.
sl@0: @SYMTestExpectedResults 1. The cache has 4 entries and is sorted in UID order.
sl@0: 	2. The oldest entry is gone from cache. The last one used is in cache.
sl@0: @SYMCR CR1182
sl@0: */
sl@0: void CCustomResolverCacheTest::TestCacheQueueFullPattern1L()
sl@0: 	{
sl@0: 	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4015 "));
sl@0: 	RArray<TUid> resolverlist(1);
sl@0: 	CleanupClosePushL(resolverlist);
sl@0: 
sl@0: 	// NB: the following insertion order caused the problem found in
sl@0: 	// INC115472. Hence there will be a check in DoQueueFullTestL
sl@0: 	// that the cache queue is sorted correctly.
sl@0: 	//
sl@0: 	// Condition for inc115472 is first insert an UID of 0xA???????
sl@0: 	// in an empty queue. Next insert an UID 0x2???????. The overflow
sl@0: 	// error causes them to be placed in the wrong order.
sl@0: 	resolverlist.AppendL(KDummyResolverUid2);
sl@0: 	resolverlist.AppendL(KDummyResolverUid1);
sl@0: 	resolverlist.AppendL(KExampleResolverUid);
sl@0: 	resolverlist.AppendL(KMyResolverUid);
sl@0: 	resolverlist.AppendL(KDummyResolverUid3);
sl@0: 	DoQueueFullTestL(resolverlist);
sl@0: 	CleanupStack::PopAndDestroy(&resolverlist);
sl@0: 	}
sl@0: 
sl@0: // In pattern 2 the oldest entry in cache has the largest UID value.
sl@0: void CCustomResolverCacheTest::TestCacheQueueFullPattern2L()
sl@0: 	{
sl@0: 	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4015 "));
sl@0: 	RArray<TUid> resolverlist(1);
sl@0: 	CleanupClosePushL(resolverlist);
sl@0: 	resolverlist.AppendL(KDummyResolverUid1);
sl@0: 	resolverlist.AppendL(KDummyResolverUid2);
sl@0: 	resolverlist.AppendL(KDummyResolverUid3);
sl@0: 	resolverlist.AppendL(KExampleResolverUid);
sl@0: 	resolverlist.AppendL(KMyResolverUid);
sl@0: 	DoQueueFullTestL(resolverlist);
sl@0: 	CleanupStack::PopAndDestroy(&resolverlist);
sl@0: 	}
sl@0: 
sl@0: // In pattern 3 the UID of the oldest entry has the second smallest value.
sl@0: void CCustomResolverCacheTest::TestCacheQueueFullPattern3L()
sl@0: 	{
sl@0: 	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4015 "));
sl@0: 	RArray<TUid> resolverlist(1);
sl@0: 	CleanupClosePushL(resolverlist);
sl@0: 	resolverlist.AppendL(KDummyResolverUid3);
sl@0: 	resolverlist.AppendL(KDummyResolverUid1);
sl@0: 	resolverlist.AppendL(KDummyResolverUid2);
sl@0: 	resolverlist.AppendL(KExampleResolverUid);
sl@0: 	resolverlist.AppendL(KMyResolverUid);
sl@0: 	DoQueueFullTestL(resolverlist);
sl@0: 	CleanupStack::PopAndDestroy(&resolverlist);
sl@0: 	}
sl@0: 
sl@0: void CCustomResolverCacheTest::DoQueueFullTestL(const RArray<TUid>& aResolverList)
sl@0: 	{
sl@0: 	// ensure cache is empty.
sl@0: 	test(CacheSize() == 0);
sl@0: 
sl@0: 	TInt maxQueueSize = ResolverCache()->iMaxCacheSize;
sl@0: 	test(aResolverList.Count() > maxQueueSize);
sl@0: 
sl@0: 	// Put 4 resolvers in the cache. Pause in between so that the time tick
sl@0: 	// of each entry is different. CacheMissPerfTestL in t_resolverperf exercises
sl@0: 	// the code path that time ticks are the same.
sl@0: 	const TInt KInBetweenDelay = 100000;
sl@0: 	TInt i;
sl@0: 	for (i = 0; i < maxQueueSize; i++)
sl@0: 		{
sl@0: 		UseResolverCheckVersionL(aResolverList[i], 0);
sl@0: 		User::AfterHighRes(KInBetweenDelay);
sl@0: 		}
sl@0: 
sl@0: 	// Check cache is full.
sl@0: 	test(CacheSize() == maxQueueSize);
sl@0: 	// Check cache is sorted properly
sl@0: 	test( QueueIsSorted() );
sl@0: 
sl@0: 	// Add one more to cache.
sl@0: 	UseResolverCheckVersionL(aResolverList[maxQueueSize], 0);
sl@0: 
sl@0: 	// Check that cache size is still full - not exceeding limit.
sl@0: 	test(CacheSize() == maxQueueSize);
sl@0: 
sl@0: 	// Want to check LRU is gone and the last resolver is now in cache.
sl@0: 	test(! HasResolverUid(aResolverList[0]));
sl@0: 	test( QueueIsSorted() );
sl@0: 	// Because of the above 3 checks, this is really redundant.
sl@0: 	test(HasResolverUid(aResolverList[maxQueueSize]));
sl@0: 
sl@0: 	// Because the timestamps of the cache entries are staggered
sl@0: 	// 100 ms apart, the mgr can only kick out 1 item at each timer expiry.
sl@0: 	// So let the cache mgr exercise this code path.
sl@0: 	TInt n = 0;
sl@0: 	while (CacheSize() > 0)
sl@0: 		{
sl@0: 		AsyncEvents.ClearAll();
sl@0: 		YieldToOtherCActive(KIndefiniteWait);  // 20 s
sl@0: 		// Check which async event has stopped the activescheduler
sl@0: 		test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );
sl@0: 		n++;
sl@0: 		}
sl@0: 
sl@0: 	// n should be five. aResolverList[0] is bumped due to queue full.
sl@0: 	// So the first timer expire will not find any expired entry.
sl@0: 	test.Printf(_L("Gone through %d loops to clear out cache.\n"), n);
sl@0: 
sl@0: 	test(n > maxQueueSize);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID		SYSLIB-ECOM-UT-4016
sl@0: @SYMTestCaseDesc 	Verify resolver is unloaded after the specified timeout.
sl@0: @SYMTestPriority 	Medium
sl@0: @SYMTestActions  	1. Use a resolver to get it in cache.
sl@0: 	2. Measure how long the entry stays in cache before it is evicted.
sl@0: @SYMTestExpectedResults The time should be >= default timeout but
sl@0: 	<= (timeout + 0.5s).
sl@0: @SYMCR CR1182
sl@0: */
sl@0: void CCustomResolverCacheTest::TestCacheTimerAccuracyL()
sl@0: 	{
sl@0: 	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4016 "));
sl@0: 	TTime start;
sl@0: 	start.UniversalTime();
sl@0: 
sl@0: 	UseResolverCheckVersionL(KMyResolverUid, 0);
sl@0: 	test( HasResolverUid(KMyResolverUid) );
sl@0: 
sl@0: 	// Wait for cache timeout
sl@0: 	AsyncEvents.ClearAll();
sl@0: 	YieldToOtherCActive(KIndefiniteWait);  // 20 s
sl@0: 	// Check which async event has stopped the activescheduler
sl@0: 	test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );
sl@0: 
sl@0: 	TInt microseconds = CalcElapsedMicroseconds(start);
sl@0: 	test.Printf(_L("Resolver is cached for %d microseconds\n"), microseconds);
sl@0: 
sl@0: 	TInt tickperiod;
sl@0: 	User::LeaveIfError(HAL::Get(HALData::ESystemTickPeriod, tickperiod));
sl@0: 	TInt lowerLimit = KCustomResolverCacheTimeout - tickperiod;
sl@0: 	test(microseconds > lowerLimit);
sl@0: 
sl@0: 	// The upper bound is tricky because there is no gaurantee on
sl@0: 	// CTimer accuracy.
sl@0: 	test(microseconds < (KCustomResolverCacheTimeout + KHalfSecond));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID		SYSLIB-ECOM-UT-4017
sl@0: @SYMTestCaseDesc 	Verify after a cache hit the time to live of the entry
sl@0: 	is extended.
sl@0: @SYMTestPriority 	High
sl@0: @SYMTestActions  	1. Record start time.
sl@0: 	2. Use a resolver to put it in cache.
sl@0: 	3. After 1 s use it again.
sl@0: 	4  Wait for its eviction.
sl@0: 	5. Check how long the entry stays in cache.
sl@0: @SYMTestExpectedResults The time should be >= 5 seconds.
sl@0: @SYMCR CR1182
sl@0: */
sl@0: void CCustomResolverCacheTest::TestTimestampUpdateOnCacheHitL()
sl@0: 	{
sl@0: 	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4017 "));
sl@0: 	// Check that the resolver is not in cache.
sl@0: 	test(! HasResolverUid(KMyResolverUid) );
sl@0: 
sl@0: 	TTime start;
sl@0: 	start.UniversalTime();
sl@0: 
sl@0: 	UseResolverCheckVersionL(KMyResolverUid, 0);
sl@0: 	test( HasResolverUid(KMyResolverUid) );
sl@0: 
sl@0: 	// Delay one second and use it again.
sl@0: 	User::AfterHighRes(KOneSecond);
sl@0: 	UseResolverCheckVersionL(KMyResolverUid, 0);
sl@0: 
sl@0: 	// Wait for its eviction
sl@0: 	while ( HasResolverUid(KMyResolverUid) )
sl@0: 		{
sl@0: 		AsyncEvents.ClearAll();
sl@0: 		YieldToOtherCActive(KIndefiniteWait);  // 20 s
sl@0: 		// Check which async event has stopped the activescheduler
sl@0: 		test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );
sl@0: 		}
sl@0: 
sl@0: 	TInt microseconds = CalcElapsedMicroseconds(start);
sl@0: 	test.Printf(_L("With cache hit, resolver is cached for %d microseconds\n"), microseconds);
sl@0: 
sl@0: 	TInt tickperiod;
sl@0: 	User::LeaveIfError(HAL::Get(HALData::ESystemTickPeriod, tickperiod));
sl@0: 	TInt lowerLimit = KCustomResolverCacheTimeout + KOneSecond - tickperiod;
sl@0: 	test(microseconds > lowerLimit);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID		SYSLIB-ECOM-UT-4018
sl@0: @SYMTestCaseDesc 	Verify at SWI start RW resolvers are evicted from cache.
sl@0: 	Verify during SWI ROM resolvers are cached but RW resolvers are not.
sl@0: @SYMTestPriority 	High
sl@0: @SYMTestActions  	1. Add a RW resolver to cache.
sl@0: 	2. Send a SWI start signal.
sl@0: 	3. Use a RW resolver.
sl@0: 	4  Use a ROM resolver.
sl@0: @SYMTestExpectedResults 1. The RW resolver is in cache.
sl@0: 	2. The cache entry is evicted.
sl@0: 	3. The RW resolver is not cached.
sl@0: 	4. The ROM resolver is cached.
sl@0: @SYMCR CR1182
sl@0: */
sl@0: void CCustomResolverCacheTest::TestSWIDisableRwResolverCachingL()
sl@0: 	{
sl@0: 	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4018 "));
sl@0: 	// The TPropertyManager protocol to setup to use a system category P&S.
sl@0: 	TInt r = PropertyManager::DeleteProperty(KUidSystemCategory,
sl@0: 		KSAUidSoftwareInstallKeyValue);
sl@0: 	test(r == KErrNone);
sl@0: 	r = PropertyManager::DefineProperty(KUidSystemCategory,
sl@0: 		KSAUidSoftwareInstallKeyValue, RProperty::EInt);
sl@0: 	test(r == KErrNone);
sl@0: 
sl@0: 	// Use a resolver in C: drive.
sl@0: 	UseResolverCheckVersionL(KDummyResolverUid1, 0);
sl@0: 	// Check that it is added to cache.
sl@0: 	test( HasResolverUid(KDummyResolverUid1) );
sl@0: 
sl@0: 	// Need a ROM entry in cache to get Bullseye to check off
sl@0: 	// a conditional. It is not an active ingredient of this test.
sl@0: 	UseResolverCheckVersionL(KMyResolverUid, 0);
sl@0: 
sl@0: 	// SWI start
sl@0: 	r = PropertyManager::SetProperty(KUidSystemCategory,
sl@0: 		KSAUidSoftwareInstallKeyValue,ESASwisInstall);
sl@0: 	test(r == KErrNone);
sl@0: 
sl@0: 	// Let CSwiChangeNotifier receive the notification
sl@0: 	AsyncEvents.ClearAll();
sl@0: 	YieldToOtherCActive(KIndefiniteWait);  // 20 s
sl@0: 	// Check we receive the correct event
sl@0: 	test( AsyncEvents.IsSet(EAsyncEvent_SwiStart) );
sl@0: 
sl@0: 	// Check the RW resolver is evicted
sl@0: 	test(! HasResolverUid(KDummyResolverUid1) );
sl@0: 
sl@0: 	// during SWI RW resolver will not be cached.
sl@0: 	UseResolverCheckVersionL(KDummyResolverUid1, 0);
sl@0: 	test(! HasResolverUid(KDummyResolverUid1) );
sl@0: 
sl@0: 	// But ROM resolvers are still cached.
sl@0: 	UseResolverCheckVersionL(KDummyResolverUid2, 0);
sl@0: 	test( HasResolverUid(KDummyResolverUid2) );
sl@0: 
sl@0: 	// And the ROM resolvers are evicted after 4 s as usual.
sl@0: 	// Note that we have KMyResolverUid and KDummyResolverUid2 in cache
sl@0: 	TBool b = WaitForEvict(KDummyResolverUid2);
sl@0: 	if (! b)
sl@0: 		{ // got KMyResolverUid only, need a second wait.
sl@0: 		b = WaitForEvict(KDummyResolverUid2);
sl@0: 		}
sl@0: 	test(b);
sl@0: 
sl@0: 	// Just for completeness. Do not really need this
sl@0: 	// for Bullseye Coverage.
sl@0: 	r = PropertyManager::SetProperty(KUidSystemCategory,
sl@0: 		KSAUidSoftwareInstallKeyValue,ESASwisNone);
sl@0: 	test(r == KErrNone);
sl@0: 	// Let CSwiChangeNotifier receive the notification
sl@0: 	AsyncEvents.ClearAll();
sl@0: 	YieldToOtherCActive(KIndefiniteWait);  // 20 s
sl@0: 	// Check we receive the correct event
sl@0: 	test( AsyncEvents.IsSet(EAsyncEvent_SwiEnd) );
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID		SYSLIB-ECOM-UT-4019
sl@0: @SYMTestCaseDesc 	Verify at BUR start RW resolvers are evicted from cache.
sl@0: 	Verify during BUR ROM resolvers are cached but RW resolvers are not.
sl@0: @SYMTestPriority 	High
sl@0: @SYMTestActions  	1. Add a RW resolver to cache.
sl@0: 	2. Send a BUR start signal.
sl@0: 	3. Use a RW resolver.
sl@0: 	4  Use a ROM resolver.
sl@0: @SYMTestExpectedResults 1. The RW resolver is in cache.
sl@0: 	2. The cache entry is evicted.
sl@0: 	3. The RW resolver is not cached.
sl@0: 	4. The ROM resolver is cached.
sl@0: @SYMCR CR1182
sl@0: */
sl@0: void CCustomResolverCacheTest::TestBurDisableRwResolverCachingL()
sl@0: 	{
sl@0: 	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4019 "));
sl@0: 	// setup backup session wrapper
sl@0: 	CBaBackupSessionWrapper* ba = CBaBackupSessionWrapper::NewL();
sl@0: 	CleanupStack::PushL(ba);
sl@0: 	TBackupOperationAttributes attribs;
sl@0: 	attribs.iFileFlag=MBackupObserver::EReleaseLockNoAccess;
sl@0: 	attribs.iOperation=MBackupOperationObserver::EStart;
sl@0: 
sl@0: 	// The backup notifier of ECOM is not registered with
sl@0: 	// BA server at construction time. It delays 15 s.
sl@0: 	// So we have to wait this long.
sl@0: 	WaitAsyncL(16);
sl@0: 
sl@0: 	// Use a resolver in C: drive.
sl@0: 	UseResolverCheckVersionL(KDummyResolverUid1, 0);
sl@0: 	// Check that it is added to cache.
sl@0: 	test( HasResolverUid(KDummyResolverUid1) );
sl@0: 
sl@0: 	// Need a ROM entry in cache to get Bullseye to check off
sl@0: 	// a conditional. It is not an active ingredient of this test.
sl@0: 	UseResolverCheckVersionL(KMyResolverUid, 0);
sl@0: 
sl@0: 	// backup start
sl@0: 	ba->NotifyBackupOperationL(attribs);
sl@0: 	// Let backup notifier receive the backup start
sl@0: 	AsyncEvents.ClearAll();
sl@0: 	YieldToOtherCActive(KIndefiniteWait);  // 20 s
sl@0: 	// Check we receive the backup start notification
sl@0: 	test( AsyncEvents.IsSet(EAsyncEvent_BurStart) );
sl@0: 
sl@0: 	// Check the RW resolver is evicted
sl@0: 	test(! HasResolverUid(KDummyResolverUid1) );
sl@0: 
sl@0: 	// during BUR RW resolver will not be cached.
sl@0: 	UseResolverCheckVersionL(KDummyResolverUid1, 0);
sl@0: 	test(! HasResolverUid(KDummyResolverUid1) );
sl@0: 
sl@0: 	// But ROM resolvers are still cached.
sl@0: 	UseResolverCheckVersionL(KDummyResolverUid2, 0);
sl@0: 	test( HasResolverUid(KDummyResolverUid2) );
sl@0: 
sl@0: 	// And the ROM resolvers are evicted after 4 s as usual.
sl@0: 	// Note that we have KMyResolverUid and KDummyResolverUid2 in cache
sl@0: 	TBool b = WaitForEvict(KDummyResolverUid2);
sl@0: 	if (! b)
sl@0: 		{ // got KMyResolverUid only, need a second wait.
sl@0: 		b = WaitForEvict(KDummyResolverUid2);
sl@0: 		}
sl@0: 	test(b);
sl@0: 
sl@0: 	// Do this for Bullseye Coverage of production code.
sl@0: 	// NB: attribs.iFileFlag stays the same
sl@0: 	attribs.iOperation=MBackupOperationObserver::EEnd;
sl@0: 	ba->NotifyBackupOperationL(attribs);
sl@0: 	// Let backup notifier receive it
sl@0: 	AsyncEvents.ClearAll();
sl@0: 	YieldToOtherCActive(KIndefiniteWait);  // 20 s
sl@0: 	// Check we receive the backup notification
sl@0: 	test( AsyncEvents.IsSet(EAsyncEvent_BurEnd) );
sl@0: 
sl@0: 	CleanupStack::PopAndDestroy(ba);
sl@0: 
sl@0: 	// to earn another Bullseye check mark.
sl@0: 	CEComServer::NotifyEvents(iEComServer, ECallBackId_None, NULL);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID		SYSLIB-ECOM-UT-4021
sl@0: @SYMTestCaseDesc 	Verify the cache timer and data to keep track of
sl@0: 	cache entry time to live are immune to device clock change.
sl@0: @SYMTestPriority 	High
sl@0: @SYMTestActions  	1. Put two resolvers in cache at 20 ticks apart.
sl@0: 	2. Spring clock forward by 5 s (1 + default cache timeout).
sl@0: 	3. Measure how long the first resolver is cached.
sl@0: 	4. Measure how long the second resolver is cached.
sl@0: 	Repeat steps 1 to 4 in setting clock backward.
sl@0: @SYMTestExpectedResults Both resolvers are cached for ~ 4 s
sl@0: 	(default cache timeout value).
sl@0: @SYMCR CR1182
sl@0: */
sl@0: void CCustomResolverCacheTest::TestClockChangeHasNoEffectOnCacheTimeoutL()
sl@0: 	{
sl@0: 	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4021 "));
sl@0: 	TInt tp;
sl@0: 	User::LeaveIfError(HAL::Get(HALData::ESystemTickPeriod, tp));
sl@0: 	TInt delayInBetween = tp * 20;
sl@0:    	test.Printf(_L("ESystemTickPeriod: %d; delayInBetween: %d;\n"), tp, delayInBetween);
sl@0: 
sl@0: 
sl@0: 	TTime beforeDelay;
sl@0: 	beforeDelay.UniversalTime();
sl@0: 
sl@0: 	UseResolverCheckVersionL(KDummyResolverUid1, 0);
sl@0: 	test( HasResolverUid(KDummyResolverUid1) );
sl@0: 
sl@0: 	User::AfterHighRes(delayInBetween);
sl@0: 	TInt elapsedBeforeTimeChange = CalcElapsedMicroseconds(beforeDelay);
sl@0: 
sl@0: 	UseResolverCheckVersionL(KDummyResolverUid2, 0);
sl@0: 	test( HasResolverUid(KDummyResolverUid2) );
sl@0: 
sl@0: 	TTimeIntervalMicroSeconds AmountOfChange(
sl@0: 		MAKE_TINT64(0, KCustomResolverCacheTimeout+KOneSecond) );
sl@0: 
sl@0: 	// Now set device clock forward
sl@0: 	TTime t;
sl@0: 	t.UniversalTime();
sl@0: 	t += AmountOfChange;
sl@0: 	User::LeaveIfError( User::SetUTCTime(t) );
sl@0: 
sl@0: 	t.UniversalTime(); // need this, apparently SetUTCTime does rounding
sl@0: 
sl@0: 	// Wait for cache timeout
sl@0: 	AsyncEvents.ClearAll();
sl@0: 	YieldToOtherCActive(KIndefiniteWait);  // 20 s
sl@0: 	// Check which async event has stopped the activescheduler
sl@0: 	test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );
sl@0: 
sl@0: 	TInt microseconds = CalcElapsedMicroseconds(t);
sl@0: 	// compensate for the 20 ticks delay
sl@0: 	microseconds += elapsedBeforeTimeChange;
sl@0: 	test.Printf(_L("Clock forward: 1st resolver is cached for %d microseconds\n"), microseconds);
sl@0: 	test(! HasResolverUid(KDummyResolverUid1) );
sl@0: 	// Check duration is between 4 to 4.5 s.
sl@0: 	TInt lowerLimit = KCustomResolverCacheTimeout - (tp*3);
sl@0: 	TInt upperLimit = (KCustomResolverCacheTimeout + KHalfSecond);
sl@0:    	test.Printf(_L("lowerLimit: %d; upperLimit: %d\n"), lowerLimit, upperLimit);	
sl@0: 	test(microseconds > lowerLimit);
sl@0: 
sl@0: 	// upper limit is tricky because there is no guarantee on CTimer
sl@0: 	// accuracy.
sl@0: 	test(microseconds <= upperLimit);
sl@0: 
sl@0: 	// Wait for eviction of the second resolver
sl@0: 	AsyncEvents.ClearAll();
sl@0: 	YieldToOtherCActive(KIndefiniteWait);  // 20 s
sl@0: 	// Check which async event has stopped the activescheduler
sl@0: 	test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );
sl@0: 
sl@0: 	microseconds = CalcElapsedMicroseconds(t);
sl@0: 	test.Printf(_L("Clock forward: 2nd resolver is cached for %d microseconds\n"), microseconds);
sl@0: 	test(! HasResolverUid(KDummyResolverUid2) );
sl@0: 	// Check duration is between 4 to 4.5 s.
sl@0: 	test(microseconds > lowerLimit);
sl@0: 	test(microseconds <= upperLimit);
sl@0: 
sl@0: 	//
sl@0: 	// Repeat for setting clock backward.
sl@0: 	//
sl@0: 	beforeDelay.UniversalTime();
sl@0: 
sl@0: 	UseResolverCheckVersionL(KDummyResolverUid1, 0);
sl@0: 	test( HasResolverUid(KDummyResolverUid1) );
sl@0: 
sl@0: 	User::AfterHighRes(delayInBetween);
sl@0: 	elapsedBeforeTimeChange = CalcElapsedMicroseconds(beforeDelay);
sl@0: 
sl@0: 	UseResolverCheckVersionL(KDummyResolverUid2, 0);
sl@0: 	test( HasResolverUid(KDummyResolverUid2) );
sl@0: 
sl@0: 	// Now set device clock backward
sl@0: 	t.UniversalTime();
sl@0: 	t -= AmountOfChange;
sl@0: 	User::LeaveIfError( User::SetUTCTime(t) );
sl@0: 	t.UniversalTime();
sl@0: 
sl@0: 	// Wait for cache timeout
sl@0: 	AsyncEvents.ClearAll();
sl@0: 	YieldToOtherCActive(KIndefiniteWait);  // 20 s
sl@0: 	// Check which async event has stopped the activescheduler
sl@0: 	test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );
sl@0: 
sl@0: 	microseconds = CalcElapsedMicroseconds(t);
sl@0: 	// compensate for the 20 ticks delay
sl@0: 	microseconds += elapsedBeforeTimeChange;
sl@0: 	test.Printf(_L("Clock backward: 1st resolver is cached for %d microseconds\n"), microseconds);
sl@0: 	test(! HasResolverUid(KDummyResolverUid1) );
sl@0: 	// Check duration is between 4 to 4.5 s.
sl@0: 	test(microseconds > lowerLimit);
sl@0: 	test(microseconds <= (KCustomResolverCacheTimeout + KHalfSecond));
sl@0: 
sl@0: 	// Wait for eviction of the second resolver
sl@0: 	AsyncEvents.ClearAll();
sl@0: 	YieldToOtherCActive(KIndefiniteWait);  // 20 s
sl@0: 	// Check which async event has stopped the activescheduler
sl@0: 	test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );
sl@0: 
sl@0: 	microseconds = CalcElapsedMicroseconds(t);
sl@0: 	test.Printf(_L("Clock backward: 2nd resolver is cached for %d microseconds\n"), microseconds);
sl@0: 	test(! HasResolverUid(KDummyResolverUid2) );
sl@0: 	// Check duration is between 4 to 4.5 s.
sl@0: 	test(microseconds > lowerLimit);
sl@0: 	test(microseconds <= (KCustomResolverCacheTimeout + KHalfSecond));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID		SYSLIB-ECOM-UT-4022
sl@0: @SYMTestCaseDesc 	Verify caching runs normally if queue size is zero.
sl@0: @SYMTestPriority 	Medium
sl@0: @SYMTestActions  	1. Set max. cache size to 0.
sl@0: 	2. Use a custom resolver.
sl@0: @SYMTestExpectedResults No leave on the list request and cache is empty.
sl@0: @SYMCR CR1182
sl@0: */
sl@0: void CCustomResolverCacheTest::TestCacheSizeZeroL()
sl@0: 	{
sl@0: 	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4022 "));
sl@0: 	ResolverCache()->iMaxCacheSize = 0;
sl@0: 	UseResolverCheckVersionL(KMyResolverUid, 0);
sl@0: 	test(! HasResolverUid(KMyResolverUid) );
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID		SYSLIB-ECOM-UT-4023
sl@0: @SYMTestCaseDesc 	Verify caching runs normally if cache timeout is zero.
sl@0: @SYMTestPriority 	Medium
sl@0: @SYMTestActions  	1. Set cache time-to-live to zero.
sl@0: 	2. Use a custom resolver.
sl@0: @SYMTestExpectedResults No leave on the list request and cache is empty.
sl@0: @SYMCR CR1182
sl@0: */
sl@0: void CCustomResolverCacheTest::TestCacheTimeoutZeroL()
sl@0: 	{
sl@0: 	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4023 "));
sl@0: 	TInt systemTickPeriod = ResolverCache()->iSystemTickPeriod;
sl@0: 	// mimic CCustomResolverCache calculate the time-to-live value.
sl@0: 	const TInt KZeroTimeout = 0;
sl@0: 	ResolverCache()->iEntryTimeToLive = (KZeroTimeout +
sl@0: 		systemTickPeriod - 1) / systemTickPeriod;
sl@0: 
sl@0: 	// run the test
sl@0: 	UseResolverCheckVersionL(KMyResolverUid, 0);
sl@0: 	test(! HasResolverUid(KMyResolverUid) );
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID		SYSLIB-ECOM-UT-4024
sl@0: @SYMTestCaseDesc 	CCustomResolverCache uses system tick to track entry
sl@0: 	time-to-live. The counter wraps around every 777 days. This test
sl@0: 	checks when wrap around occurs cached entry is purged correctly.
sl@0: @SYMTestPriority 	Medium
sl@0: @SYMTestActions  	1. Use a resolver to get it in cache.
sl@0: 	2. Set its time-of-use to 0xFFFFFFFF.
sl@0: 	3. Wait for cache timer expire.
sl@0: @SYMTestExpectedResults The entry is evicted on first timer expiry and
sl@0: 	the entry stays in cache for ~ 4s.
sl@0: @SYMCR CR1182
sl@0: */
sl@0: void CCustomResolverCacheTest::TestCounterWrapAroundL()
sl@0: 	{
sl@0: 	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4024 "));
sl@0: 	TTime start;
sl@0: 	start.UniversalTime();
sl@0: 
sl@0: 	UseResolverCheckVersionL(KMyResolverUid, 0);
sl@0: 	RResolverCacheEntry& entry = ResolverCache()->iResolvers[0];
sl@0: 	test( entry.iResolverUid == KMyResolverUid );
sl@0: 
sl@0: 	// Set time-of-use to edge of wrap around
sl@0: 	entry.iLastUse.iTicks = KMaxTUint;
sl@0: 
sl@0: 	// Wait for cache timeout
sl@0: 	AsyncEvents.ClearAll();
sl@0: 	YieldToOtherCActive(KIndefiniteWait);  // 20 s
sl@0: 	// Check which async event has stopped the activescheduler
sl@0: 	test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );
sl@0: 
sl@0: 	TInt microseconds = CalcElapsedMicroseconds(start);
sl@0: 	test.Printf(_L("Wrap around: resolver is cached for %d microseconds\n"), microseconds);
sl@0: 
sl@0: 	TInt tickperiod;
sl@0: 	User::LeaveIfError(HAL::Get(HALData::ESystemTickPeriod, tickperiod));
sl@0: 	TInt lowerLimit = KCustomResolverCacheTimeout - tickperiod;
sl@0: 	test(microseconds > lowerLimit);
sl@0: 	// Upper limit must have a wide margin because there is no gaurantee
sl@0: 	// on CTimer accuracy.
sl@0: 	test(microseconds < (KCustomResolverCacheTimeout + KHalfSecond));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID		SYSLIB-ECOM-UT-4025
sl@0: @SYMTestCaseDesc 	Verify if cannot find the NewL method in the proxy
sl@0: 	instantiation table, ECOM returns KEComErrNoResolver
sl@0: @SYMTestPriority 	Medium
sl@0: @SYMTestActions  	Use a resolver whose proxy table has the wrong Impl. Uid.
sl@0: @SYMTestExpectedResults Get KEComErrNoResolver error
sl@0: @SYMCR CR1182
sl@0: */
sl@0: void CCustomResolverCacheTest::TestResolverWithBadProxyTable()
sl@0: 	{
sl@0: 	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4025 "));
sl@0: 	const TUid KBadResolverUid = {0x10009DDF};
sl@0: 	TRAPD(err, UseResolverCheckVersionL(KBadResolverUid, 0) );
sl@0: 	test(err == KEComErrNoResolver);
sl@0: 	}
sl@0: 
sl@0: /** wrapper to run all the Basic and OOM tests */
sl@0: void CCustomResolverCacheTest::RunAllTestsL()
sl@0: 	{
sl@0: 	CopyPluginsL();
sl@0: 
sl@0: 	test.Next(_L("Basic TestCounterWrapAroundL"));
sl@0: 	DoBasicTestL(&CCustomResolverCacheTest::TestCounterWrapAroundL);
sl@0: 
sl@0: 	test.Next(_L("Basic TestUpgradingCachedResolverL"));
sl@0: 	DoBasicTestL(&CCustomResolverCacheTest::TestUpgradingCachedResolverL);
sl@0: 
sl@0: 	test.Next(_L("Basic TestCacheQueueFullPattern1L"));
sl@0: 	DoBasicTestL(&CCustomResolverCacheTest::TestCacheQueueFullPattern1L);
sl@0: 
sl@0: 	test.Next(_L("Basic TestCacheQueueFullPattern2L"));
sl@0: 	DoBasicTestL(&CCustomResolverCacheTest::TestCacheQueueFullPattern2L);
sl@0: 
sl@0: 	test.Next(_L("Basic TestCacheQueueFullPattern3L"));
sl@0: 	DoBasicTestL(&CCustomResolverCacheTest::TestCacheQueueFullPattern3L);
sl@0: 
sl@0: 	test.Next(_L("Basic TestCacheTimerAccuracyL"));
sl@0: 	DoBasicTestL(&CCustomResolverCacheTest::TestCacheTimerAccuracyL);
sl@0: 
sl@0: 	test.Next(_L("Basic TestTimestampUpdateOnCacheHitL"));
sl@0: 	DoBasicTestL(&CCustomResolverCacheTest::TestTimestampUpdateOnCacheHitL);
sl@0: 
sl@0: 	test.Next(_L("Basic TestSWIDisableRwResolverCachingL"));
sl@0: 	DoBasicTestL(&CCustomResolverCacheTest::TestSWIDisableRwResolverCachingL);
sl@0: 
sl@0: 	test.Next(_L("Basic TestBurDisableRwResolverCachingL"));
sl@0: 	DoBasicTestL(&CCustomResolverCacheTest::TestBurDisableRwResolverCachingL);
sl@0: 
sl@0: 	test.Next(_L("Basic TestClockChangeHasNoEffectOnCacheTimeoutL"));
sl@0: 	DoBasicTestL(&CCustomResolverCacheTest::TestClockChangeHasNoEffectOnCacheTimeoutL);
sl@0: 
sl@0: 	test.Next(_L("Basic TestCacheSizeZeroL"));
sl@0: 	DoBasicTestL(&CCustomResolverCacheTest::TestCacheSizeZeroL);
sl@0: 
sl@0: 	test.Next(_L("Basic TestCacheTimeoutZeroL"));
sl@0: 	DoBasicTestL(&CCustomResolverCacheTest::TestCacheTimeoutZeroL);
sl@0: 
sl@0: 	test.Next(_L("Basic TestResolverWithBadProxyTable"));
sl@0: 	DoBasicTestL(&CCustomResolverCacheTest::TestResolverWithBadProxyTable);
sl@0: 
sl@0: 	// Only run OOM on tests which do not involve rescan dir.
sl@0: 	test.Next(_L("OOM TestCacheQueueFullPattern3L"));
sl@0: 	DoOOMTestL(&CCustomResolverCacheTest::TestCacheQueueFullPattern3L);
sl@0: 
sl@0: 	test.Next(_L("OOM TestCacheTimerAccuracyL"));
sl@0: 	DoOOMTestL(&CCustomResolverCacheTest::TestCacheTimerAccuracyL);
sl@0: 
sl@0: 	test.Next(_L("OOM TestTimestampUpdateOnCacheHitL"));
sl@0: 	DoOOMTestL(&CCustomResolverCacheTest::TestTimestampUpdateOnCacheHitL);
sl@0: 
sl@0: 	// Do all tests affected by Lazy DLL unload last.
sl@0: 	test.Next(_L("Basic TestDeletingCachedResolverL"));
sl@0: 	DoBasicTestL(&CCustomResolverCacheTest::TestDeletingCachedResolverL);
sl@0: 	}
sl@0: 
sl@0: static TInt KillEComServer()
sl@0: 	{
sl@0: 	//Need to ensure that the EComServer process is killed before even starting this test by using
sl@0:    	//the EComTestUtils library
sl@0:    	_LIT(KEComServerProcessName,"ecomserver");
sl@0:    	TRAPD(err, EComTestUtils::KillProcessL(KEComServerProcessName));
sl@0:    	return err;
sl@0: 	}
sl@0: 
sl@0: GLDEF_C TInt E32Main()
sl@0: 	{
sl@0: 	__UHEAP_MARK;
sl@0: 
sl@0: 	beginningOfTest.UniversalTime();
sl@0: 
sl@0: 	test.Printf(_L("\n"));
sl@0: 	test.Title();
sl@0: 	test.Start( _L("Custom Resolver Cache") );
sl@0: 
sl@0: 
sl@0: 	TheTrapCleanup = CTrapCleanup::New();
sl@0: 	test(TheTrapCleanup != NULL);
sl@0: 
sl@0: 	// Connect the file server instance
sl@0: 	test(KErrNone == TheFs.Connect());
sl@0: 
sl@0: 	TheActiveScheduler = new CDerivedActiveScheduler;
sl@0: 	test(TheActiveScheduler != NULL);
sl@0: 	CActiveScheduler::Install(TheActiveScheduler);
sl@0: 
sl@0: 	TInt err = ::KillEComServer();
sl@0: 	test(err == KErrNotFound || err == KErrNone);
sl@0: 
sl@0: 	// Call the main tests
sl@0: 	TRAP(err, CCustomResolverCacheTest::RunAllTestsL());
sl@0: 	if (err != KErrNone) test.Printf(_L("RunAllTestsL() error, %d\n"), err);
sl@0: 	test(err == KErrNone);
sl@0: 
sl@0: 	// remove the RAMOnly files
sl@0: 	TRAP_IGNORE( WaitForLazyUnloadingL() );
sl@0: 	DeleteTestPlugin();
sl@0: 	User::After(KOneSecond * 3);
sl@0: 
sl@0: 	delete TheActiveScheduler;
sl@0: 	delete TheTrapCleanup;
sl@0: 
sl@0: 	TheFs.Close();
sl@0: 
sl@0: 	test.End();
sl@0: 	test.Close();
sl@0: 
sl@0: 	__UHEAP_MARKEND;
sl@0: 	return (KErrNone);
sl@0: 	}