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