// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// This file contains test classes and their implementations
// to test production class CCustomResolverCache.
// 
//

#include <e32test.h>
#include <f32file.h>
#include <hal.h>
#include <bautils.h>
#include <babitflags.h>
#include <babackup.h>
#include <startup.hrh>
#include <ecom/resolver.h>
#include "EComErrorCodes.h"
#include "EComUidCodes.h"
#include "ImplementationInformation.h"
#include "RegistryData.h"
#include "Registrar.h"
#include "RegistrarObserver.h"
#include "../EcomTestUtils/EcomTestUtils.h"
#include <swi/swispubsubdefs.h>
#include "../EcomTestUtils/TPropertyManager.h"
#include "EComPatchDataConstantv2.h"
#include "RegistryResolveTransaction.h"  // ecom3 code
#include "callback.h"
#include "resolvercache.h"
#include "EComServer.h"


const TInt KOneSecond = 1000000;
const TInt KHalfSecond = KOneSecond / 2;
// Use this timeout to wait for events occuring within a few seconds.
const TInt KIndefiniteWait = KOneSecond * 20;

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

LOCAL_D RFs					TheFs;
LOCAL_D CTrapCleanup* 		TheTrapCleanup 		= NULL;
class CDerivedActiveScheduler;
LOCAL_D CDerivedActiveScheduler* TheActiveScheduler	= NULL;


// custom resolvers available for testing.
// 200126cd, A0001346 and A0001347 are allocated outside the
// ECOM Uid Allocations.doc
const TUid KDummyResolverUid2  = {0xA0001346};
const TUid KDummyResolverUid3  = {0xA0001347};
const TUid KExampleResolverUid = {0x10009DD0};
const TUid KMyResolverUid      = {0x10009E12};
const TUid KDummyResolverUid1  = {0x200126CD};

// The custom resolver in RAMOnly dir
_LIT(KDummyRscInC, "c:\\resource\\plugins\\dummycustomresolver1.rsc");
_LIT(KDummyDllInC, "c:\\sys\\bin\\dummycustomresolver1.dll");

_LIT(KDummyRscInZ, "z:\\ramonly\\dummycustomresolver1.rsc");
_LIT(KDummyDllInZ, "z:\\ramonly\\dummycustomresolver1.dll");

// This pair is to upgrade a resolver DLL.
// NB: to supersede a Z: drive plugin, the C: DLL must have the
// same name as the one in z: drive. Hence the '2' is dropped.
_LIT(KDllUpgradeInZ, "z:\\ramonly\\cachedcustomresolver2.dll");
_LIT(KDllUpgradeInC, "c:\\sys\\bin\\cachedcustomresolver.dll");

_LIT(KRscUpgradeInZ, "z:\\ramonly\\cachedcustomresolver2.rsc");
_LIT(KRscUpgradeInC, "c:\\resource\\plugins\\cachedcustomresolver.rsc");

/** User::AfterHighRes is not a reliable mechanism to wait
for async events. Especially when we have 4 different timers
firing within a span of 4 s. Hence this harness intercepts
and inserts callbacks in the notification sources and set
the following flag to indicate what event has occured. */
LOCAL_D TBitFlags32 AsyncEvents = 0;

/** enum to identify different async events */
enum TAsyncEventId
	{
	EAsyncEvent_Unknown = 0,
	EAsyncEvent_ImplUpgrade,
	EAsyncEvent_SwiStart,
	EAsyncEvent_SwiEnd,
	EAsyncEvent_BurStart,
	EAsyncEvent_BurEnd,
	EAsyncEvent_CacheTimer,
	EAsyncEvent_HaltTimer
	};

//
// maps callback data to enum TAsyncEventId.
LOCAL_C TAsyncEventId CallbackDataToEventId(TInt aEvent, TAny* aData)
	{
	TAsyncEventId ret = EAsyncEvent_Unknown;
	TCallBackState* state = static_cast<TCallBackState*>(aData);
	if (aEvent == ECallBackId_SwiEvent)
		{
		if (*state == ECallBackState_EventStart)
			{
			ret = EAsyncEvent_SwiStart;
			}
		else // treat all unexpected states as SWI end!
			{
			ret = EAsyncEvent_SwiEnd;
			}
		}
	else if (aEvent == ECallBackId_BurEvent)
		{
		if (*state == ECallBackState_EventStart)
			{
			ret = EAsyncEvent_BurStart;
			}
		else // treat all unexpected states as BUR finish!
			{
			ret = EAsyncEvent_BurEnd;
			}
		}
	else if (aEvent == ECallBackId_ImplUpgrade)
		{
		ret = EAsyncEvent_ImplUpgrade;
		}
	return ret;
	}

// beginningOfTest is set when this harness is run.
LOCAL_D TTime beginningOfTest;
LOCAL_C void WaitForLazyUnloadingL()
	{
	TTime now;
	now.UniversalTime();

	TTimeIntervalSeconds n;
	User::LeaveIfError(now.SecondsFrom(beginningOfTest, n));
	const TInt KLazyDllUnloadPeriod =  150; // actual is 2 minutes
	TInt secondsToWait = KLazyDllUnloadPeriod - n.Int();
	test.Printf(_L("Amount to wait for lazy unload is %d seconds.\n"), secondsToWait);
	if (secondsToWait > 0)
		{
		User::After(KOneSecond * secondsToWait);
		}
	}

// Copies the Plugins to specific folder for testing purpose
LOCAL_C void CopyPluginsL()
	{
	EComTestUtils::FileManCopyFileL(KDummyRscInZ, KDummyRscInC);
	EComTestUtils::FileManCopyFileL(KDummyDllInZ, KDummyDllInC);
	}

// Deleting plugin from the RAM for cleanup purpose
LOCAL_C void DeleteTestPlugin()
	{
	TRAP_IGNORE(EComTestUtils::FileManDeleteFileL(KDummyRscInC));
	TRAP_IGNORE(EComTestUtils::FileManDeleteFileL(KDummyDllInC));

	TRAP_IGNORE(EComTestUtils::FileManDeleteFileL(KRscUpgradeInC));
	TRAP_IGNORE(EComTestUtils::FileManDeleteFileL(KDllUpgradeInC));
	}

// utility to help cast TTimeIntervalMicroSeconds to TInt
LOCAL_C TInt CalcElapsedMicroseconds(const TTime& aStart)
	{
	TTime now;
	now.UniversalTime();
	TTimeIntervalMicroSeconds timediff = now.MicroSecondsFrom(aStart);
	return I64LOW( timediff.Int64() );
	}

/** Need a CActive to wait for various change notifications. */
class CHaltTimer : public CTimer
	{
public:
	CHaltTimer(TInt aPriority);
	~CHaltTimer();
	void ConstructL();
	void StartTimer(TInt aTimeInterval);

private:
	void RunL();
	};

CHaltTimer::CHaltTimer(TInt aPriority)
	: CTimer(aPriority)
	{
	CActiveScheduler::Add(this);
	}

CHaltTimer::~CHaltTimer()
	{
	Cancel();
	}

void CHaltTimer::ConstructL()
	{
	CTimer::ConstructL();
	}

void CHaltTimer::StartTimer(TInt aTimeInterval)
	{
	After(aTimeInterval);
	}

void CHaltTimer::RunL()
	{
	AsyncEvents.Set(EAsyncEvent_HaltTimer);
	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);
	}

/** friend class to access private members of CEComServer */
class TEComServer_StateAccessor
	{
public:
	static void InterceptCallbacks(CEComServer& aEComServer, TCallBackWithArg aCb);
	static CCustomResolverCache* GetResolverCache(CEComServer& aEComServer);
	};

/** Test class for object CCustomResolverCache.
*/
class CCustomResolverCacheTest : public CBase
	{
public:
	typedef void (CCustomResolverCacheTest::*ClassFuncPtrL) (void);

	virtual ~CCustomResolverCacheTest();
	static CCustomResolverCacheTest* NewL();
	static void RunAllTestsL();
	static TInt InterceptCacheMgrCallback(TAny* aObj, TInt aEvent, TAny* aData);
	static TInt CacheTimeoutCallback(TAny* aObj, TInt aEvent, TAny* aData);

private:
	CCustomResolverCacheTest();
	void ConstructL();

	static void DoBasicTestL(ClassFuncPtrL aTestFunc);
	static void DoOOMTestL(ClassFuncPtrL aTestFunc);

	// Test cases
	void TestUpgradingCachedResolverL();
	void TestDeletingCachedResolverL();

	void TestCacheQueueFullPattern1L();
	void TestCacheQueueFullPattern2L();
	void TestCacheQueueFullPattern3L();
	void DoQueueFullTestL(const RArray<TUid>& aResolverList);

	void TestCounterWrapAroundL();
	void TestCacheTimerAccuracyL();
	void TestTimestampUpdateOnCacheHitL();
	void TestSWIDisableRwResolverCachingL();
	void TestBurDisableRwResolverCachingL();
	void TestClockChangeHasNoEffectOnCacheTimeoutL();
	void TestCacheSizeZeroL();
	void TestCacheTimeoutZeroL();
	void TestResolverWithBadProxyTable();

	// utilities
	TBool UseResolverCheckVersionL(TUid aResolverUid,
								   TInt aVersion = 0);
	void YieldToOtherCActive(TInt aMicroSeconds);
	void WaitAsyncL(TInt aNumSeconds);
	TBool WaitForEvict(TUid aResolverUid);

	// access private data of CCustomResolverCache
	TInt CacheSize();
	TBool HasResolverUid(TUid aUid);
	TBool QueueIsSorted();
	inline CCustomResolverCache* ResolverCache();

private:
	/** need a CActive to wait for other async events */
	CHaltTimer* iHaltTimer;

	CEComServer* iEComServer;
	};

//==============================================
// class TEComServer_StateAccessor
//==============================================
void TEComServer_StateAccessor::InterceptCallbacks(CEComServer& aEComServer,
												   TCallBackWithArg aCb)
	{
	aEComServer.iRegistrar->InstallSwiEventCallBack(aCb);
	aEComServer.iRegistrar->InstallBurEventCallBack(aCb);
	aEComServer.iRegistryData->SetImplUpgradeCallBack(aCb);
	}

CCustomResolverCache*
TEComServer_StateAccessor::GetResolverCache(CEComServer& aEComServer)
	{
	return aEComServer.iResolverCache;
	}

//==============================================
// class CCustomResolverCacheTest
//==============================================

/** CCustomResolverCacheTest constructor */
CCustomResolverCacheTest::CCustomResolverCacheTest()
	{
	}

/** CCustomResolverCacheTest destructor. */
CCustomResolverCacheTest::~CCustomResolverCacheTest()
	{
	delete iEComServer;
	delete iHaltTimer;
	}

/** static factory method to instantiate CCustomResolverCacheTest object.
*/
CCustomResolverCacheTest* CCustomResolverCacheTest::NewL()
	{
	CCustomResolverCacheTest* self = new(ELeave) CCustomResolverCacheTest;
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

/**
Standardized 2nd phase of two phase construction.
*/
void CCustomResolverCacheTest::ConstructL()
	{
	iHaltTimer = new(ELeave) CHaltTimer(CActive::EPriorityIdle);
	iHaltTimer->ConstructL();

	iEComServer = CEComServer::NewLC();
	CleanupStack::Pop(iEComServer);

	TCallBackWithArg interceptorCB(&InterceptCacheMgrCallback, this);
	TEComServer_StateAccessor::InterceptCallbacks(*iEComServer, interceptorCB);

	TCallBackWithArg cacheTimerCb(&CacheTimeoutCallback, this);
	ResolverCache()->iTimerExpireCB = cacheTimerCb;
	}

/** util to fetch CEComServer::iResolverCache */
inline CCustomResolverCache* CCustomResolverCacheTest::ResolverCache()
	{
	return TEComServer_StateAccessor::GetResolverCache(*iEComServer);
	}

/** the test harness install this callback with ECOM server objects
to intercept async events. This callback will relay the original
call to CEComServer, then raise a flag to indicate what
event has occurred.
@param aObj pointer to the CCustomResolverCacheTest object
@param aEvent ID of event triggering the callback
@param aData  pointer to some data associated with the event.
@return Always KErrNone. It is ignored.
*/
TInt CCustomResolverCacheTest::InterceptCacheMgrCallback(TAny* aObj,
														 TInt aEvent,
														 TAny* aData)
	{
	CCustomResolverCacheTest* self = static_cast<CCustomResolverCacheTest*>(aObj);
	// Pass the event along to let CEComServer does its thing.
	CEComServer::NotifyEvents(self->iEComServer, aEvent, aData);

	if (self->iHaltTimer->IsActive())
		{
		TAsyncEventId event = CallbackDataToEventId(aEvent, aData);
		AsyncEvents.Set(event);

		self->iHaltTimer->Cancel();
		CActiveScheduler::Stop();
		}
	else
		{
		// BUR and SWI unit test cases just call the notifier
		// directly. So CHaltTimer is not running.
		test.Printf(_L("CacheTest: caught async event %d when timer not running\n"), aEvent);
		}
	return KErrNone;
	}

/** A callback installed in cache mgr. Whenever the cache timer expires
this callback is invoked by CCustomResolverCache
@param aObj pointer to CCustomResolverCacheTest
@return Always KErrNone. It is ignored.
*/
TInt CCustomResolverCacheTest::CacheTimeoutCallback(TAny* aObj, TInt, TAny*)
	{
	AsyncEvents.Set(EAsyncEvent_CacheTimer);

	CCustomResolverCacheTest* self = static_cast<CCustomResolverCacheTest*>(aObj);
	self->iHaltTimer->Cancel();
	CActiveScheduler::Stop();
	return KErrNone;
	}

/** Wrapper function to run normal mode (non-OOM) test
*/
void CCustomResolverCacheTest::DoBasicTestL(ClassFuncPtrL aTestFunc)
	{
	__UHEAP_MARK;
	TInt startProcessHandleCount;
	TInt startThreadHandleCount;
	RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

	CCustomResolverCacheTest* p = CCustomResolverCacheTest::NewL();
	(p->*aTestFunc)();
	delete p;

	// check that no handles have leaked
	TInt endProcessHandleCount;
	TInt endThreadHandleCount;
	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

	test(startProcessHandleCount == endProcessHandleCount);
	test(startThreadHandleCount  == endThreadHandleCount);
	__UHEAP_MARKEND;
	}

/**
@SYMTestCaseID		SYSLIB-ECOM-UT-4020
@SYMTestCaseDesc 	Verify no memory leak in CCustomResolverCache.
@SYMTestPriority 	Critical
@SYMTestActions  	Run UT-4015, UT-4016 and UT-4017 under OOM.
@SYMTestExpectedResults No memory leak, no handle leak.
@SYMCR CR1182
*/
void CCustomResolverCacheTest::DoOOMTestL(ClassFuncPtrL aTestFunc)
	{
	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4020 "));
	__UHEAP_MARK;
	TInt startProcessHandleCount;
	TInt startThreadHandleCount;
	RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
	TInt err(KErrNone);
	TInt oomStep = 0;

	do {
		// Instantiation of CCustomResolverCacheTest involves building
		// the registry. It will take couple hours under OOM. Hence do it
		// outside __UHEAP_SETFAIL.
		CCustomResolverCacheTest* p = CCustomResolverCacheTest::NewL();

		__UHEAP_SETFAIL(RHeap::EDeterministic, ++oomStep);
		TRAP(err, (p->*aTestFunc)());
		__UHEAP_SETFAIL(RHeap::ENone, 0);

		delete p;
	} while (err == KErrNoMemory);

	test(err == KErrNone);
	test.Printf(_L("OOM succeeded at heap failure rate %d\n"), oomStep);

	// check that no handles have leaked
	TInt endProcessHandleCount;
	TInt endThreadHandleCount;
	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

	test(startProcessHandleCount == endProcessHandleCount);
	test(startThreadHandleCount  == endThreadHandleCount);
	__UHEAP_MARKEND;
	}

/** helper, ecom3 code
Issue a list request to add resolver to cache and check if
the registry has the expected version of the resolver.
@param aResolverUid the custom resolver to create
@param aVersion the expected version of the custom resolver. Check is skipped
  if aVersion is zero.
*/
TBool CCustomResolverCacheTest::UseResolverCheckVersionL(TUid aResolverUid,
														TInt aVersion)
	{
	TEComResolverParams resolverparams;
	_LIT8(KDummyData,"dummy");
	resolverparams.SetDataType(KDummyData);

	TClientRequest clientReq;
	RArray<TUid> extendedInterfaces;
	RImplInfoArray* infoArray = iEComServer->ListImplementationsL(
		KCustomResolverInterfaceUid, resolverparams, aResolverUid,
		extendedInterfaces, clientReq);

	TBool ret = (aVersion == 0);

	// infoArray not pushed because there are no leave in this search.
	for (TInt i = 0; !ret && i < infoArray->Count(); i++)
		{
		const CImplementationInformation* impl = (*infoArray)[i];
		if (impl->ImplementationUid() == aResolverUid && impl->Version() == aVersion)
			{
			ret = ETrue;
			}
		}

	infoArray->Reset();
	delete infoArray;

	return ret;
	}

/** utility to let other CActive s to run. */
void CCustomResolverCacheTest::YieldToOtherCActive(TInt aMicroSeconds)
	{
	iHaltTimer->StartTimer(aMicroSeconds);
	CActiveScheduler::Start();
	}

/** Call YieldToOtherCActive as many times as needed
until aNumSeconds is reached. */
void CCustomResolverCacheTest::WaitAsyncL(TInt aNumSeconds)
	{
	TTime start, now;
	start.UniversalTime();
	TTimeIntervalSeconds elapsed;

	for (elapsed = 0; elapsed.Int() < aNumSeconds; )
		{
		AsyncEvents.ClearAll();
		TInt seconds = (aNumSeconds - elapsed.Int());
		YieldToOtherCActive(KOneSecond * seconds);
		now.UniversalTime();
		User::LeaveIfError(now.SecondsFrom(start, elapsed));
		}
	}

/**
This method is used in the situation that cache timer is already
started when we load the given resolver. Then when cache timer
expires, the resolver is not ripe to be evicted. Have to wait a
second time.
@param aResolverUid the Resolver to wait for evict.
@return ETrue means the resolver is evicted correctly.
		EFalse means error, i.e. test fail.
*/
TBool CCustomResolverCacheTest::WaitForEvict(TUid aResolverUid)
	{
	TBool ret = EFalse;
	// No point of waiting for 20s for cache timeout.
	TInt waitMicroSec = KCustomResolverCacheTimeout + KOneSecond;
	for (TInt i = 0; (i < 2) && !ret; i++)
		{
		AsyncEvents.ClearAll();
		YieldToOtherCActive(waitMicroSec);
		// Check which async event has stopped the activescheduler
		test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );
		ret = ! HasResolverUid(aResolverUid);
		}
	return ret;
	}

//==========================================================
// utilities to access internal data of CCustomResolverCache.
// This is possible because CCustomResolverCacheTest is a friend.
//===========================================================

TInt CCustomResolverCacheTest::CacheSize()
	{
	return ResolverCache()->iResolvers.Count();
	}

TBool CCustomResolverCacheTest::HasResolverUid(TUid aUid)
	{
	for (TInt i = 0; i < ResolverCache()->iResolvers.Count(); i++)
		{
		if (ResolverCache()->iResolvers[i].iResolverUid == aUid)
			{
			return ETrue;
			}
		}
    return EFalse;
	}

TBool CCustomResolverCacheTest::QueueIsSorted()
	{
	CCustomResolverCache* theResolverCache = ResolverCache();
	for (TInt i = 1; i < theResolverCache->iResolvers.Count(); i++)
		{
		if (theResolverCache->iResolvers[i-1].iResolverUid.iUid >=
			theResolverCache->iResolvers[i].iResolverUid.iUid)
			{
			test.Printf(_L("Sort error: i-1 %d, 0x%8X, 0x%8X\n"), i-1,
				theResolverCache->iResolvers[i-1].iResolverUid.iUid,
				theResolverCache->iResolvers[i].iResolverUid.iUid	);
			return EFalse;
			}
		}
    return ETrue;
	}

/**
@SYMTestCaseID		SYSLIB-ECOM-CT-4012
@SYMTestCaseDesc 	If a cached resolver is superseded by a new version, it
	is evicted from cache.
@SYMTestPriority 	High
@SYMTestActions  	1. Use a custom resolver to get it in cache.
	2. copy the upgrade version of the resolver to C: and wait for
	   its discovery.
@SYMTestExpectedResults 1. a/. The resolver is the base version.
       b/. It is added in the cache.
	2. a/. Cache mgr receives upgrade notification (from CRegistryData).
	   b/. The resolver entry disappears from cache and the cache timer is
	       still running.
@SYMCR CR1182
*/
void CCustomResolverCacheTest::TestUpgradingCachedResolverL()
	{
	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-4012 "));
	// get the customer resolver in cache. It should be version 1.
	test (UseResolverCheckVersionL(KMyResolverUid, 1));
	// Check that KMyResolverUid is added to cache.
	test(HasResolverUid(KMyResolverUid));

	// Need an extra item in cache to get Bullseye to check off
	// a conditional. It is not an active ingredient of this test.
	UseResolverCheckVersionL(KDummyResolverUid1, 0);

	// Copy the upgrade to C: drive
	EComTestUtils::FileManCopyFileL(KRscUpgradeInZ, KRscUpgradeInC);
	EComTestUtils::FileManCopyFileL(KDllUpgradeInZ, KDllUpgradeInC);

	// Let CDiscoverer discover the resource file.
	AsyncEvents.ClearAll();
	YieldToOtherCActive(KIndefiniteWait);  // 20 s

	// Check which async event has stopped the activescheduler
	test( AsyncEvents.IsSet(EAsyncEvent_ImplUpgrade) );

	// And the cache entry should be gone.
	test(! HasResolverUid(KMyResolverUid));

	// cleanup. NB: we never loaded the DLL in C: drive so
	// no need to worry about lazy dll unloading.
	EComTestUtils::FileManDeleteFileL(KRscUpgradeInC);
	EComTestUtils::FileManDeleteFileL(KDllUpgradeInC);
	}

/**
@SYMTestCaseID		SYSLIB-ECOM-CT-4013
@SYMTestCaseDesc 	Verify a cached DLL cannot be deleted until it
	is removed from cache. This test serves as a sanity check that
	ECOM does need these notifications to trigger unloading DLL
	on SWI and BUR events.
@SYMTestPriority 	Medium
@SYMTestActions  	1. Use a RW drive resolver to get it in cache.
	2. Try to delete the DLL within default cache timeout period.
    3. Try again after it is evicted from cache.
@SYMTestExpectedResults 1. The resolver is added in cache.
	2. Get KErrAccessDenied error.
	3. The delete is either KErrNone or KErrNotFound because in step 2
	   even though the return code is -21, the file may be actually gone.
@SYMCR CR1182
*/
void CCustomResolverCacheTest::TestDeletingCachedResolverL()
	{
	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-4013 "));
	// NB: lazy Dll unloading interferes with this test.
	// Best to run this test at the end.
	WaitForLazyUnloadingL();

	// There is only 1 version of 200126CD. No need to check version.
	// So ignore the return code.
	UseResolverCheckVersionL(KDummyResolverUid1, 0);

	// Check that it is added to cache.
	test( HasResolverUid(KDummyResolverUid1) );

	TInt err(KErrNone);
	TRAP(err, EComTestUtils::FileManDeleteFileL(KDummyDllInC));

#ifndef __WINSCW__
	// On hw you can delete the DLL while it is loaded.
	if (err == KErrNone)
		{
		test.Printf(_L("Delete test: RFs allows deletion of loaded DLL on hw. Test not run.\n"));
		EComTestUtils::FileManCopyFileL(KDummyDllInZ, KDummyDllInC);
		return;
		}
#endif

	test(err == KErrAccessDenied);

	// Wait for its eviction after cache timeout.
	AsyncEvents.ClearAll();
	YieldToOtherCActive(KIndefiniteWait);  // 20 s

	// Check which async event has stopped the activescheduler
	test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );
	// Check the resolver is evicted
	test( !HasResolverUid(KDummyResolverUid1) );

	TRAP(err, EComTestUtils::FileManDeleteFileL(KDummyDllInC));
	test(err == KErrNone || err == KErrNotFound);

	// restore the file
	EComTestUtils::FileManCopyFileL(KDummyDllInZ, KDummyDllInC);
	}

/**
@SYMTestCaseID		SYSLIB-ECOM-UT-4015
@SYMTestCaseDesc 	Verify cache queue does not grow beyond the max
	queue size. Verify when a resolver is added to a full cache,
	the one to evict is the least recently used.

	There are 3 versions of this test. In Pattern1, the LRU entry
	has UID value which is the smallest of the 5 resolvers.
	In pattern 2, UID of the LRU is greatest. In pattern 3, UID of the
	LRU is the second smallest.
@SYMTestPriority 	High
@SYMTestActions  	1. Use 4 different resolvers to fill up the cache.
	2. Use a fifth one to bump off the least recently used entry.
    Run these two steps with the LRU entry in different positions in the
	queue, i.e. it is first, second, and last in the queue.
@SYMTestExpectedResults 1. The cache has 4 entries and is sorted in UID order.
	2. The oldest entry is gone from cache. The last one used is in cache.
@SYMCR CR1182
*/
void CCustomResolverCacheTest::TestCacheQueueFullPattern1L()
	{
	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4015 "));
	RArray<TUid> resolverlist(1);
	CleanupClosePushL(resolverlist);

	// NB: the following insertion order caused the problem found in
	// INC115472. Hence there will be a check in DoQueueFullTestL
	// that the cache queue is sorted correctly.
	//
	// Condition for inc115472 is first insert an UID of 0xA???????
	// in an empty queue. Next insert an UID 0x2???????. The overflow
	// error causes them to be placed in the wrong order.
	resolverlist.AppendL(KDummyResolverUid2);
	resolverlist.AppendL(KDummyResolverUid1);
	resolverlist.AppendL(KExampleResolverUid);
	resolverlist.AppendL(KMyResolverUid);
	resolverlist.AppendL(KDummyResolverUid3);
	DoQueueFullTestL(resolverlist);
	CleanupStack::PopAndDestroy(&resolverlist);
	}

// In pattern 2 the oldest entry in cache has the largest UID value.
void CCustomResolverCacheTest::TestCacheQueueFullPattern2L()
	{
	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4015 "));
	RArray<TUid> resolverlist(1);
	CleanupClosePushL(resolverlist);
	resolverlist.AppendL(KDummyResolverUid1);
	resolverlist.AppendL(KDummyResolverUid2);
	resolverlist.AppendL(KDummyResolverUid3);
	resolverlist.AppendL(KExampleResolverUid);
	resolverlist.AppendL(KMyResolverUid);
	DoQueueFullTestL(resolverlist);
	CleanupStack::PopAndDestroy(&resolverlist);
	}

// In pattern 3 the UID of the oldest entry has the second smallest value.
void CCustomResolverCacheTest::TestCacheQueueFullPattern3L()
	{
	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4015 "));
	RArray<TUid> resolverlist(1);
	CleanupClosePushL(resolverlist);
	resolverlist.AppendL(KDummyResolverUid3);
	resolverlist.AppendL(KDummyResolverUid1);
	resolverlist.AppendL(KDummyResolverUid2);
	resolverlist.AppendL(KExampleResolverUid);
	resolverlist.AppendL(KMyResolverUid);
	DoQueueFullTestL(resolverlist);
	CleanupStack::PopAndDestroy(&resolverlist);
	}

void CCustomResolverCacheTest::DoQueueFullTestL(const RArray<TUid>& aResolverList)
	{
	// ensure cache is empty.
	test(CacheSize() == 0);

	TInt maxQueueSize = ResolverCache()->iMaxCacheSize;
	test(aResolverList.Count() > maxQueueSize);

	// Put 4 resolvers in the cache. Pause in between so that the time tick
	// of each entry is different. CacheMissPerfTestL in t_resolverperf exercises
	// the code path that time ticks are the same.
	const TInt KInBetweenDelay = 100000;
	TInt i;
	for (i = 0; i < maxQueueSize; i++)
		{
		UseResolverCheckVersionL(aResolverList[i], 0);
		User::AfterHighRes(KInBetweenDelay);
		}

	// Check cache is full.
	test(CacheSize() == maxQueueSize);
	// Check cache is sorted properly
	test( QueueIsSorted() );

	// Add one more to cache.
	UseResolverCheckVersionL(aResolverList[maxQueueSize], 0);

	// Check that cache size is still full - not exceeding limit.
	test(CacheSize() == maxQueueSize);

	// Want to check LRU is gone and the last resolver is now in cache.
	test(! HasResolverUid(aResolverList[0]));
	test( QueueIsSorted() );
	// Because of the above 3 checks, this is really redundant.
	test(HasResolverUid(aResolverList[maxQueueSize]));

	// Because the timestamps of the cache entries are staggered
	// 100 ms apart, the mgr can only kick out 1 item at each timer expiry.
	// So let the cache mgr exercise this code path.
	TInt n = 0;
	while (CacheSize() > 0)
		{
		AsyncEvents.ClearAll();
		YieldToOtherCActive(KIndefiniteWait);  // 20 s
		// Check which async event has stopped the activescheduler
		test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );
		n++;
		}

	// n should be five. aResolverList[0] is bumped due to queue full.
	// So the first timer expire will not find any expired entry.
	test.Printf(_L("Gone through %d loops to clear out cache.\n"), n);

	test(n > maxQueueSize);
	}

/**
@SYMTestCaseID		SYSLIB-ECOM-UT-4016
@SYMTestCaseDesc 	Verify resolver is unloaded after the specified timeout.
@SYMTestPriority 	Medium
@SYMTestActions  	1. Use a resolver to get it in cache.
	2. Measure how long the entry stays in cache before it is evicted.
@SYMTestExpectedResults The time should be >= default timeout but
	<= (timeout + 0.5s).
@SYMCR CR1182
*/
void CCustomResolverCacheTest::TestCacheTimerAccuracyL()
	{
	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4016 "));
	TTime start;
	start.UniversalTime();

	UseResolverCheckVersionL(KMyResolverUid, 0);
	test( HasResolverUid(KMyResolverUid) );

	// Wait for cache timeout
	AsyncEvents.ClearAll();
	YieldToOtherCActive(KIndefiniteWait);  // 20 s
	// Check which async event has stopped the activescheduler
	test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );

	TInt microseconds = CalcElapsedMicroseconds(start);
	test.Printf(_L("Resolver is cached for %d microseconds\n"), microseconds);

	TInt tickperiod;
	User::LeaveIfError(HAL::Get(HALData::ESystemTickPeriod, tickperiod));
	TInt lowerLimit = KCustomResolverCacheTimeout - tickperiod;
	test(microseconds > lowerLimit);

	// The upper bound is tricky because there is no gaurantee on
	// CTimer accuracy.
	test(microseconds < (KCustomResolverCacheTimeout + KHalfSecond));
	}

/**
@SYMTestCaseID		SYSLIB-ECOM-UT-4017
@SYMTestCaseDesc 	Verify after a cache hit the time to live of the entry
	is extended.
@SYMTestPriority 	High
@SYMTestActions  	1. Record start time.
	2. Use a resolver to put it in cache.
	3. After 1 s use it again.
	4  Wait for its eviction.
	5. Check how long the entry stays in cache.
@SYMTestExpectedResults The time should be >= 5 seconds.
@SYMCR CR1182
*/
void CCustomResolverCacheTest::TestTimestampUpdateOnCacheHitL()
	{
	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4017 "));
	// Check that the resolver is not in cache.
	test(! HasResolverUid(KMyResolverUid) );

	TTime start;
	start.UniversalTime();

	UseResolverCheckVersionL(KMyResolverUid, 0);
	test( HasResolverUid(KMyResolverUid) );

	// Delay one second and use it again.
	User::AfterHighRes(KOneSecond);
	UseResolverCheckVersionL(KMyResolverUid, 0);

	// Wait for its eviction
	while ( HasResolverUid(KMyResolverUid) )
		{
		AsyncEvents.ClearAll();
		YieldToOtherCActive(KIndefiniteWait);  // 20 s
		// Check which async event has stopped the activescheduler
		test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );
		}

	TInt microseconds = CalcElapsedMicroseconds(start);
	test.Printf(_L("With cache hit, resolver is cached for %d microseconds\n"), microseconds);

	TInt tickperiod;
	User::LeaveIfError(HAL::Get(HALData::ESystemTickPeriod, tickperiod));
	TInt lowerLimit = KCustomResolverCacheTimeout + KOneSecond - tickperiod;
	test(microseconds > lowerLimit);
	}

/**
@SYMTestCaseID		SYSLIB-ECOM-UT-4018
@SYMTestCaseDesc 	Verify at SWI start RW resolvers are evicted from cache.
	Verify during SWI ROM resolvers are cached but RW resolvers are not.
@SYMTestPriority 	High
@SYMTestActions  	1. Add a RW resolver to cache.
	2. Send a SWI start signal.
	3. Use a RW resolver.
	4  Use a ROM resolver.
@SYMTestExpectedResults 1. The RW resolver is in cache.
	2. The cache entry is evicted.
	3. The RW resolver is not cached.
	4. The ROM resolver is cached.
@SYMCR CR1182
*/
void CCustomResolverCacheTest::TestSWIDisableRwResolverCachingL()
	{
	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4018 "));
	// The TPropertyManager protocol to setup to use a system category P&S.
	TInt r = PropertyManager::DeleteProperty(KUidSystemCategory,
		KSAUidSoftwareInstallKeyValue);
	test(r == KErrNone);
	r = PropertyManager::DefineProperty(KUidSystemCategory,
		KSAUidSoftwareInstallKeyValue, RProperty::EInt);
	test(r == KErrNone);

	// Use a resolver in C: drive.
	UseResolverCheckVersionL(KDummyResolverUid1, 0);
	// Check that it is added to cache.
	test( HasResolverUid(KDummyResolverUid1) );

	// Need a ROM entry in cache to get Bullseye to check off
	// a conditional. It is not an active ingredient of this test.
	UseResolverCheckVersionL(KMyResolverUid, 0);

	// SWI start
	r = PropertyManager::SetProperty(KUidSystemCategory,
		KSAUidSoftwareInstallKeyValue,ESASwisInstall);
	test(r == KErrNone);

	// Let CSwiChangeNotifier receive the notification
	AsyncEvents.ClearAll();
	YieldToOtherCActive(KIndefiniteWait);  // 20 s
	// Check we receive the correct event
	test( AsyncEvents.IsSet(EAsyncEvent_SwiStart) );

	// Check the RW resolver is evicted
	test(! HasResolverUid(KDummyResolverUid1) );

	// during SWI RW resolver will not be cached.
	UseResolverCheckVersionL(KDummyResolverUid1, 0);
	test(! HasResolverUid(KDummyResolverUid1) );

	// But ROM resolvers are still cached.
	UseResolverCheckVersionL(KDummyResolverUid2, 0);
	test( HasResolverUid(KDummyResolverUid2) );

	// And the ROM resolvers are evicted after 4 s as usual.
	// Note that we have KMyResolverUid and KDummyResolverUid2 in cache
	TBool b = WaitForEvict(KDummyResolverUid2);
	if (! b)
		{ // got KMyResolverUid only, need a second wait.
		b = WaitForEvict(KDummyResolverUid2);
		}
	test(b);

	// Just for completeness. Do not really need this
	// for Bullseye Coverage.
	r = PropertyManager::SetProperty(KUidSystemCategory,
		KSAUidSoftwareInstallKeyValue,ESASwisNone);
	test(r == KErrNone);
	// Let CSwiChangeNotifier receive the notification
	AsyncEvents.ClearAll();
	YieldToOtherCActive(KIndefiniteWait);  // 20 s
	// Check we receive the correct event
	test( AsyncEvents.IsSet(EAsyncEvent_SwiEnd) );
	}

/**
@SYMTestCaseID		SYSLIB-ECOM-UT-4019
@SYMTestCaseDesc 	Verify at BUR start RW resolvers are evicted from cache.
	Verify during BUR ROM resolvers are cached but RW resolvers are not.
@SYMTestPriority 	High
@SYMTestActions  	1. Add a RW resolver to cache.
	2. Send a BUR start signal.
	3. Use a RW resolver.
	4  Use a ROM resolver.
@SYMTestExpectedResults 1. The RW resolver is in cache.
	2. The cache entry is evicted.
	3. The RW resolver is not cached.
	4. The ROM resolver is cached.
@SYMCR CR1182
*/
void CCustomResolverCacheTest::TestBurDisableRwResolverCachingL()
	{
	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4019 "));
	// setup backup session wrapper
	CBaBackupSessionWrapper* ba = CBaBackupSessionWrapper::NewL();
	CleanupStack::PushL(ba);
	TBackupOperationAttributes attribs;
	attribs.iFileFlag=MBackupObserver::EReleaseLockNoAccess;
	attribs.iOperation=MBackupOperationObserver::EStart;

	// The backup notifier of ECOM is not registered with
	// BA server at construction time. It delays 15 s.
	// So we have to wait this long.
	WaitAsyncL(16);

	// Use a resolver in C: drive.
	UseResolverCheckVersionL(KDummyResolverUid1, 0);
	// Check that it is added to cache.
	test( HasResolverUid(KDummyResolverUid1) );

	// Need a ROM entry in cache to get Bullseye to check off
	// a conditional. It is not an active ingredient of this test.
	UseResolverCheckVersionL(KMyResolverUid, 0);

	// backup start
	ba->NotifyBackupOperationL(attribs);
	// Let backup notifier receive the backup start
	AsyncEvents.ClearAll();
	YieldToOtherCActive(KIndefiniteWait);  // 20 s
	// Check we receive the backup start notification
	test( AsyncEvents.IsSet(EAsyncEvent_BurStart) );

	// Check the RW resolver is evicted
	test(! HasResolverUid(KDummyResolverUid1) );

	// during BUR RW resolver will not be cached.
	UseResolverCheckVersionL(KDummyResolverUid1, 0);
	test(! HasResolverUid(KDummyResolverUid1) );

	// But ROM resolvers are still cached.
	UseResolverCheckVersionL(KDummyResolverUid2, 0);
	test( HasResolverUid(KDummyResolverUid2) );

	// And the ROM resolvers are evicted after 4 s as usual.
	// Note that we have KMyResolverUid and KDummyResolverUid2 in cache
	TBool b = WaitForEvict(KDummyResolverUid2);
	if (! b)
		{ // got KMyResolverUid only, need a second wait.
		b = WaitForEvict(KDummyResolverUid2);
		}
	test(b);

	// Do this for Bullseye Coverage of production code.
	// NB: attribs.iFileFlag stays the same
	attribs.iOperation=MBackupOperationObserver::EEnd;
	ba->NotifyBackupOperationL(attribs);
	// Let backup notifier receive it
	AsyncEvents.ClearAll();
	YieldToOtherCActive(KIndefiniteWait);  // 20 s
	// Check we receive the backup notification
	test( AsyncEvents.IsSet(EAsyncEvent_BurEnd) );

	CleanupStack::PopAndDestroy(ba);

	// to earn another Bullseye check mark.
	CEComServer::NotifyEvents(iEComServer, ECallBackId_None, NULL);
	}

/**
@SYMTestCaseID		SYSLIB-ECOM-UT-4021
@SYMTestCaseDesc 	Verify the cache timer and data to keep track of
	cache entry time to live are immune to device clock change.
@SYMTestPriority 	High
@SYMTestActions  	1. Put two resolvers in cache at 20 ticks apart.
	2. Spring clock forward by 5 s (1 + default cache timeout).
	3. Measure how long the first resolver is cached.
	4. Measure how long the second resolver is cached.
	Repeat steps 1 to 4 in setting clock backward.
@SYMTestExpectedResults Both resolvers are cached for ~ 4 s
	(default cache timeout value).
@SYMCR CR1182
*/
void CCustomResolverCacheTest::TestClockChangeHasNoEffectOnCacheTimeoutL()
	{
	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4021 "));
	TInt tp;
	User::LeaveIfError(HAL::Get(HALData::ESystemTickPeriod, tp));
	TInt delayInBetween = tp * 20;
   	test.Printf(_L("ESystemTickPeriod: %d; delayInBetween: %d;\n"), tp, delayInBetween);


	TTime beforeDelay;
	beforeDelay.UniversalTime();

	UseResolverCheckVersionL(KDummyResolverUid1, 0);
	test( HasResolverUid(KDummyResolverUid1) );

	User::AfterHighRes(delayInBetween);
	TInt elapsedBeforeTimeChange = CalcElapsedMicroseconds(beforeDelay);

	UseResolverCheckVersionL(KDummyResolverUid2, 0);
	test( HasResolverUid(KDummyResolverUid2) );

	TTimeIntervalMicroSeconds AmountOfChange(
		MAKE_TINT64(0, KCustomResolverCacheTimeout+KOneSecond) );

	// Now set device clock forward
	TTime t;
	t.UniversalTime();
	t += AmountOfChange;
	User::LeaveIfError( User::SetUTCTime(t) );

	t.UniversalTime(); // need this, apparently SetUTCTime does rounding

	// Wait for cache timeout
	AsyncEvents.ClearAll();
	YieldToOtherCActive(KIndefiniteWait);  // 20 s
	// Check which async event has stopped the activescheduler
	test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );

	TInt microseconds = CalcElapsedMicroseconds(t);
	// compensate for the 20 ticks delay
	microseconds += elapsedBeforeTimeChange;
	test.Printf(_L("Clock forward: 1st resolver is cached for %d microseconds\n"), microseconds);
	test(! HasResolverUid(KDummyResolverUid1) );
	// Check duration is between 4 to 4.5 s.
	TInt lowerLimit = KCustomResolverCacheTimeout - (tp*3);
	TInt upperLimit = (KCustomResolverCacheTimeout + KHalfSecond);
   	test.Printf(_L("lowerLimit: %d; upperLimit: %d\n"), lowerLimit, upperLimit);	
	test(microseconds > lowerLimit);

	// upper limit is tricky because there is no guarantee on CTimer
	// accuracy.
	test(microseconds <= upperLimit);

	// Wait for eviction of the second resolver
	AsyncEvents.ClearAll();
	YieldToOtherCActive(KIndefiniteWait);  // 20 s
	// Check which async event has stopped the activescheduler
	test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );

	microseconds = CalcElapsedMicroseconds(t);
	test.Printf(_L("Clock forward: 2nd resolver is cached for %d microseconds\n"), microseconds);
	test(! HasResolverUid(KDummyResolverUid2) );
	// Check duration is between 4 to 4.5 s.
	test(microseconds > lowerLimit);
	test(microseconds <= upperLimit);

	//
	// Repeat for setting clock backward.
	//
	beforeDelay.UniversalTime();

	UseResolverCheckVersionL(KDummyResolverUid1, 0);
	test( HasResolverUid(KDummyResolverUid1) );

	User::AfterHighRes(delayInBetween);
	elapsedBeforeTimeChange = CalcElapsedMicroseconds(beforeDelay);

	UseResolverCheckVersionL(KDummyResolverUid2, 0);
	test( HasResolverUid(KDummyResolverUid2) );

	// Now set device clock backward
	t.UniversalTime();
	t -= AmountOfChange;
	User::LeaveIfError( User::SetUTCTime(t) );
	t.UniversalTime();

	// Wait for cache timeout
	AsyncEvents.ClearAll();
	YieldToOtherCActive(KIndefiniteWait);  // 20 s
	// Check which async event has stopped the activescheduler
	test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );

	microseconds = CalcElapsedMicroseconds(t);
	// compensate for the 20 ticks delay
	microseconds += elapsedBeforeTimeChange;
	test.Printf(_L("Clock backward: 1st resolver is cached for %d microseconds\n"), microseconds);
	test(! HasResolverUid(KDummyResolverUid1) );
	// Check duration is between 4 to 4.5 s.
	test(microseconds > lowerLimit);
	test(microseconds <= (KCustomResolverCacheTimeout + KHalfSecond));

	// Wait for eviction of the second resolver
	AsyncEvents.ClearAll();
	YieldToOtherCActive(KIndefiniteWait);  // 20 s
	// Check which async event has stopped the activescheduler
	test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );

	microseconds = CalcElapsedMicroseconds(t);
	test.Printf(_L("Clock backward: 2nd resolver is cached for %d microseconds\n"), microseconds);
	test(! HasResolverUid(KDummyResolverUid2) );
	// Check duration is between 4 to 4.5 s.
	test(microseconds > lowerLimit);
	test(microseconds <= (KCustomResolverCacheTimeout + KHalfSecond));
	}

/**
@SYMTestCaseID		SYSLIB-ECOM-UT-4022
@SYMTestCaseDesc 	Verify caching runs normally if queue size is zero.
@SYMTestPriority 	Medium
@SYMTestActions  	1. Set max. cache size to 0.
	2. Use a custom resolver.
@SYMTestExpectedResults No leave on the list request and cache is empty.
@SYMCR CR1182
*/
void CCustomResolverCacheTest::TestCacheSizeZeroL()
	{
	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4022 "));
	ResolverCache()->iMaxCacheSize = 0;
	UseResolverCheckVersionL(KMyResolverUid, 0);
	test(! HasResolverUid(KMyResolverUid) );
	}

/**
@SYMTestCaseID		SYSLIB-ECOM-UT-4023
@SYMTestCaseDesc 	Verify caching runs normally if cache timeout is zero.
@SYMTestPriority 	Medium
@SYMTestActions  	1. Set cache time-to-live to zero.
	2. Use a custom resolver.
@SYMTestExpectedResults No leave on the list request and cache is empty.
@SYMCR CR1182
*/
void CCustomResolverCacheTest::TestCacheTimeoutZeroL()
	{
	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4023 "));
	TInt systemTickPeriod = ResolverCache()->iSystemTickPeriod;
	// mimic CCustomResolverCache calculate the time-to-live value.
	const TInt KZeroTimeout = 0;
	ResolverCache()->iEntryTimeToLive = (KZeroTimeout +
		systemTickPeriod - 1) / systemTickPeriod;

	// run the test
	UseResolverCheckVersionL(KMyResolverUid, 0);
	test(! HasResolverUid(KMyResolverUid) );
	}

/**
@SYMTestCaseID		SYSLIB-ECOM-UT-4024
@SYMTestCaseDesc 	CCustomResolverCache uses system tick to track entry
	time-to-live. The counter wraps around every 777 days. This test
	checks when wrap around occurs cached entry is purged correctly.
@SYMTestPriority 	Medium
@SYMTestActions  	1. Use a resolver to get it in cache.
	2. Set its time-of-use to 0xFFFFFFFF.
	3. Wait for cache timer expire.
@SYMTestExpectedResults The entry is evicted on first timer expiry and
	the entry stays in cache for ~ 4s.
@SYMCR CR1182
*/
void CCustomResolverCacheTest::TestCounterWrapAroundL()
	{
	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4024 "));
	TTime start;
	start.UniversalTime();

	UseResolverCheckVersionL(KMyResolverUid, 0);
	RResolverCacheEntry& entry = ResolverCache()->iResolvers[0];
	test( entry.iResolverUid == KMyResolverUid );

	// Set time-of-use to edge of wrap around
	entry.iLastUse.iTicks = KMaxTUint;

	// Wait for cache timeout
	AsyncEvents.ClearAll();
	YieldToOtherCActive(KIndefiniteWait);  // 20 s
	// Check which async event has stopped the activescheduler
	test( AsyncEvents.IsSet(EAsyncEvent_CacheTimer) );

	TInt microseconds = CalcElapsedMicroseconds(start);
	test.Printf(_L("Wrap around: resolver is cached for %d microseconds\n"), microseconds);

	TInt tickperiod;
	User::LeaveIfError(HAL::Get(HALData::ESystemTickPeriod, tickperiod));
	TInt lowerLimit = KCustomResolverCacheTimeout - tickperiod;
	test(microseconds > lowerLimit);
	// Upper limit must have a wide margin because there is no gaurantee
	// on CTimer accuracy.
	test(microseconds < (KCustomResolverCacheTimeout + KHalfSecond));
	}

/**
@SYMTestCaseID		SYSLIB-ECOM-UT-4025
@SYMTestCaseDesc 	Verify if cannot find the NewL method in the proxy
	instantiation table, ECOM returns KEComErrNoResolver
@SYMTestPriority 	Medium
@SYMTestActions  	Use a resolver whose proxy table has the wrong Impl. Uid.
@SYMTestExpectedResults Get KEComErrNoResolver error
@SYMCR CR1182
*/
void CCustomResolverCacheTest::TestResolverWithBadProxyTable()
	{
	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-4025 "));
	const TUid KBadResolverUid = {0x10009DDF};
	TRAPD(err, UseResolverCheckVersionL(KBadResolverUid, 0) );
	test(err == KEComErrNoResolver);
	}

/** wrapper to run all the Basic and OOM tests */
void CCustomResolverCacheTest::RunAllTestsL()
	{
	CopyPluginsL();

	test.Next(_L("Basic TestCounterWrapAroundL"));
	DoBasicTestL(&CCustomResolverCacheTest::TestCounterWrapAroundL);

	test.Next(_L("Basic TestUpgradingCachedResolverL"));
	DoBasicTestL(&CCustomResolverCacheTest::TestUpgradingCachedResolverL);

	test.Next(_L("Basic TestCacheQueueFullPattern1L"));
	DoBasicTestL(&CCustomResolverCacheTest::TestCacheQueueFullPattern1L);

	test.Next(_L("Basic TestCacheQueueFullPattern2L"));
	DoBasicTestL(&CCustomResolverCacheTest::TestCacheQueueFullPattern2L);

	test.Next(_L("Basic TestCacheQueueFullPattern3L"));
	DoBasicTestL(&CCustomResolverCacheTest::TestCacheQueueFullPattern3L);

	test.Next(_L("Basic TestCacheTimerAccuracyL"));
	DoBasicTestL(&CCustomResolverCacheTest::TestCacheTimerAccuracyL);

	test.Next(_L("Basic TestTimestampUpdateOnCacheHitL"));
	DoBasicTestL(&CCustomResolverCacheTest::TestTimestampUpdateOnCacheHitL);

	test.Next(_L("Basic TestSWIDisableRwResolverCachingL"));
	DoBasicTestL(&CCustomResolverCacheTest::TestSWIDisableRwResolverCachingL);

	test.Next(_L("Basic TestBurDisableRwResolverCachingL"));
	DoBasicTestL(&CCustomResolverCacheTest::TestBurDisableRwResolverCachingL);

	test.Next(_L("Basic TestClockChangeHasNoEffectOnCacheTimeoutL"));
	DoBasicTestL(&CCustomResolverCacheTest::TestClockChangeHasNoEffectOnCacheTimeoutL);

	test.Next(_L("Basic TestCacheSizeZeroL"));
	DoBasicTestL(&CCustomResolverCacheTest::TestCacheSizeZeroL);

	test.Next(_L("Basic TestCacheTimeoutZeroL"));
	DoBasicTestL(&CCustomResolverCacheTest::TestCacheTimeoutZeroL);

	test.Next(_L("Basic TestResolverWithBadProxyTable"));
	DoBasicTestL(&CCustomResolverCacheTest::TestResolverWithBadProxyTable);

	// Only run OOM on tests which do not involve rescan dir.
	test.Next(_L("OOM TestCacheQueueFullPattern3L"));
	DoOOMTestL(&CCustomResolverCacheTest::TestCacheQueueFullPattern3L);

	test.Next(_L("OOM TestCacheTimerAccuracyL"));
	DoOOMTestL(&CCustomResolverCacheTest::TestCacheTimerAccuracyL);

	test.Next(_L("OOM TestTimestampUpdateOnCacheHitL"));
	DoOOMTestL(&CCustomResolverCacheTest::TestTimestampUpdateOnCacheHitL);

	// Do all tests affected by Lazy DLL unload last.
	test.Next(_L("Basic TestDeletingCachedResolverL"));
	DoBasicTestL(&CCustomResolverCacheTest::TestDeletingCachedResolverL);
	}

static TInt KillEComServer()
	{
	//Need to ensure that the EComServer process is killed before even starting this test by using
   	//the EComTestUtils library
   	_LIT(KEComServerProcessName,"ecomserver");
   	TRAPD(err, EComTestUtils::KillProcessL(KEComServerProcessName));
   	return err;
	}

GLDEF_C TInt E32Main()
	{
	__UHEAP_MARK;

	beginningOfTest.UniversalTime();

	test.Printf(_L("\n"));
	test.Title();
	test.Start( _L("Custom Resolver Cache") );


	TheTrapCleanup = CTrapCleanup::New();
	test(TheTrapCleanup != NULL);

	// Connect the file server instance
	test(KErrNone == TheFs.Connect());

	TheActiveScheduler = new CDerivedActiveScheduler;
	test(TheActiveScheduler != NULL);
	CActiveScheduler::Install(TheActiveScheduler);

	TInt err = ::KillEComServer();
	test(err == KErrNotFound || err == KErrNone);

	// Call the main tests
	TRAP(err, CCustomResolverCacheTest::RunAllTestsL());
	if (err != KErrNone) test.Printf(_L("RunAllTestsL() error, %d\n"), err);
	test(err == KErrNone);

	// remove the RAMOnly files
	TRAP_IGNORE( WaitForLazyUnloadingL() );
	DeleteTestPlugin();
	User::After(KOneSecond * 3);

	delete TheActiveScheduler;
	delete TheTrapCleanup;

	TheFs.Close();

	test.End();
	test.Close();

	__UHEAP_MARKEND;
	return (KErrNone);
	}