// Copyright (c) 2004-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 CLoadManager. Where necessary stubs

// are implemented to help in writing test harness using RTest.

// Plugins available to be used in this test

// Interface UID	DLL	UID		Implementation UID	Version		DllFile

// 0x10009DC0		0x10009DB1	0x10009DC3			1		Z:\\..\\EComExample.dll

// 0x10009DB1	0x10009DC4			1		Z:\\..\\EComExample.dll

// 0x10009DB3	0x10009DC3			2		Z:\\..\\EComExample2.dll

// 0x10009DB3	0x10009DC4			2		Z:\\..\\EComExample2.dll

// 0x101F8477	0x101F8478			1		Z:\\..\\EComExample3.dll

// 0x101F8479  0x101F847A			1		Z:\\..\\EComExample4.dll

// 0x101F847B	0x101F847C			1		C:\\..\\EComExample5.dll

// 0x10282331		0x10282330	0x10282332			1		Z:\\..\\EComLoadMgrExample1.dll

// 0x10282330	0x10282334			1		Z:\\..\\EComLoadMgrExample1.dll

// 0x10282335	0x10282333			1		Z:\\..\\EComLoadMgrExample2.dll

// 

//

#include <e32test.h>

#include <f32file.h>

#include <bautils.h>

#include <e32uid.h>

#include "LoadManager.h"

#include <ecom/ecomerrorcodes.h>

#include "EComUidCodes.h"

#include "RegistryData.h"

#include <ecom/implementationinformation.h>

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

#include "Interface.h"

#include "UnloadPolicy.h"

// ---------------------------------------------------------------------------

// Test and Leave framework

LOCAL_D RTest TheTest(_L("t_loadmanager.exe"));

LOCAL_C void Check(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		//DeleteTestPlugin();

		TheTest(EFalse, aLine);

		}

	}

LOCAL_C void Check(TInt aValue, TInt aExpected, TInt aLine)

	{

	if(aValue != aExpected)

		{

		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

		//DeleteTestPlugin();

		TheTest(EFalse, aLine);

		}

	}

#define TEST(arg) ::Check((arg), __LINE__)

#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

//Leave with info message printed out

LOCAL_C void Leave(TInt aError, TInt aLine)

	{

	RDebug::Print(_L("*** Leave. Error: %d, Line: %d\r\n"), aError, aLine);

	User::Leave(aError);

	}

//Use LEAVE() macro instead of User::Leave() and LEAVE_IF_ERROR() macro instead of

//User::LeaveIfError(). They will print the line number, where the "leave" was called.

#define LEAVE(aError) ::Leave(aError, __LINE__)

// ---------------------------------------------------------------------------

LOCAL_D RFs					TheFs;

LOCAL_D CTrapCleanup* 		TheTrapCleanup 		= NULL;

LOCAL_D CActiveScheduler*	TheActiveScheduler	= NULL;

//Plugins files used for this test program

_LIT(KResourceFileName5, "C:\\resource\\plugins\\EComExample5.RSC");

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

_LIT(KExampleDllFileName4,"Z:\\sys\\bin\\EComExample4.dll");

_LIT(KExampleDllFileName3,"Z:\\sys\\bin\\EComExample3.dll");

_LIT(KExampleDllFileName2,"Z:\\sys\\bin\\EComExample2.dll");

_LIT(KLoadMgrExample1DllName,"Z:\\sys\\bin\\EComLoadMgrExample1.dll");

_LIT(KLoadMgrExample2DllName,"Z:\\sys\\bin\\EComLoadMgrExample2.dll");

_LIT(KResourceFileName5OnZ, "z:\\RAMOnly\\EComExample5.RSC");

_LIT(KExampleDllFileName10,"Z:\\sys\\bin\\EComExample10.dll");

_LIT(KNULLString,"");

_LIT(KExampleDllFileName12,"C:\\sys\\bin\\EComExample12.dll");

_LIT(KExampleDllFileName12OnZ, "z:\\RAMOnly\\EComExample12.dll");

_LIT(KResourceFileName12, "C:\\resource\\plugins\\EComExample12.RSC");

_LIT(KResourceFileName12OnZ, "z:\\RAMOnly\\EComExample12.RSC");

//Contains files that are part of ROM that must be

//Copied to the RAM for test purposes

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

// Used for supressing warning in OOM tests

#define __UNUSED_VAR(var) var = var

const TInt KOneSecond = 1000000;

// Utility clean up function

void CleanupEComArray(TAny* aArray);

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

//from normal test and from OOM TheTest.

static void LeaveIfErrNoMemory(TInt aError)

	{

	if(aError == KErrNoMemory)

		{

		LEAVE(aError);

		}

	}

/**

Test State Accessor class for CLoadManager

This class will be used to access the state

of the policy array within CLoadManager

*/

class TLoadManager_StateAccessor

	{

public:

	//Return the number of instance index inside iInstanceInfoList

	TInt InstanceIndexCount(CLoadManager& aLoadManager);

	//Return the number of unload policy inside iAllUnloadPolicies

	TInt UnloadPolicyCount(CLoadManager& aLoadManager);

	//Return a pointer to Instance Index item inside the instance index array

	CInstanceInfo* InstanceIndex(const TInt& aInt,CLoadManager& aLoadManager);

	//Return a pointer to UnloadPolicy item inside the array

	CUnloadPolicy* UnloadPolicy(const TInt& aInt,CLoadManager& aLoadManager);

	//Return a pointer to garbage UnloadPolicy

	CUnloadPolicy* GarbagePolicy(CLoadManager& aLoadManager);

	//Return a count to the number of extended objects within an Extended instance.

	// Must pass in the index of a valid extended instance

	TInt ExtendedInstanceCount(const TInt& aInt,CLoadManager& aLoadManager);

	};

TInt TLoadManager_StateAccessor::InstanceIndexCount(CLoadManager& aLoadManager)

	{

	return aLoadManager.iInstanceInfoList.Count();

	}

TInt TLoadManager_StateAccessor::UnloadPolicyCount(CLoadManager& aLoadManager)

	{

	return aLoadManager.iAllUnloadPolicies.Count();

	}

CInstanceInfo* TLoadManager_StateAccessor::InstanceIndex(const TInt& aInt,CLoadManager& aLoadManager)

	{

	return (aLoadManager.iInstanceInfoList[aInt]);

	}

CUnloadPolicy* TLoadManager_StateAccessor::UnloadPolicy(const TInt& aInt,CLoadManager& aLoadManager)

	{

	return aLoadManager.iAllUnloadPolicies[aInt];

	}

CUnloadPolicy* TLoadManager_StateAccessor::GarbagePolicy(CLoadManager& aLoadManager)

	{

	return aLoadManager.iGarbagePolicy;

	}

TInt TLoadManager_StateAccessor::ExtendedInstanceCount(const TInt& aInt,CLoadManager& aLoadManager)

	{

	CInstanceInfoExtended* instanceExtended = static_cast<CInstanceInfoExtended*>(aLoadManager.iInstanceInfoList[aInt]);

	return instanceExtended->iExtendedObjectInfo.Count();

	}

/**

Test class for object CLoadManager.

The class provides the parameters and behaviour that

allows this class to behave normally under a test scenario.

*/

class CLoadManagerTest : public CBase

	{

public:

	static CLoadManagerTest* NewL();

	virtual inline ~CLoadManagerTest();

	void InstantiationMethodTestL(TUid aDllUid, const TDesC& aDllName, const TUid aIICType);

	void DestroyThisTestL(TUid aDllUid, const TDesC& aDllName, const TUid aIICType);

	void CreateDestroyTestCase1L(TUid aDllUid1,

	  	            			  TUid aImplUid1,

								  const TDesC& aDllName1,

								  TUid aDllUid2,

								  TUid aImplUid2,

								  const TDesC& aDllName2,

								  const TUid aIICType);

	void CreateDestroyTestCase2L(TUid aDllUid,

								   TUid aImplUid1,

								   const TDesC& aDllName,

								   TUid aImplUid2,

								   const TUid aIICType);

	void CreateDestroyTestCase3L();

	void CreateDestroyTestCase4L(TUid aDllUid,TUid aImplUid,const TDesC& aDllName,const TUid aIICType);

	void CreateDestroyTestCase5L(TUid aDllUid1,

	  	            		  			TUid aImplUid1,

							  			const TDesC& aDllName1,

							  			TUid aDllUid2,

							  			TUid aImplUid2,

							  			const TDesC& aDllName2,

							  			TUid aImplUid3,

							  			const TUid aIICType);

	void SpecialOOMTestCaseL();

	void InstantiationMethodTestPlugin1L();

	void InstantiationMethodTestPlugin3L();

	void ImplementationObjectTestL();

	void GetImplementationUidTestL();

	void DestroyThisTestPlugin1L();

	void DestroyThisTestPlugin3L();

	void CreateDestroyTestCase1Plugin1L();

	void CreateDestroyTestCase1Plugin3L();

	void CreateDestroyTestCase2Plugin1L();

	void CreateDestroyTestCase2Plugin3L();

	void CreateDestroyTestCase3Plugin3L();

	void CreateDestroyTestCase4Plugin1L();

	void CreateDestroyTestCase4Plugin3L();

	void CreateDestroyTestCase5Plugin1L();

	void CreateDestroyTestCase5Plugin3L();

	// Extended methods

	void ExtendedMethodTest1Plugin3L();

	void ExtendedMethodTest2Plugin3L();

	void ManuallyReleaseExtendedInterfaceTestL();

	void CreateDestroyTestCase1PluginAndPlugin3L();

private:

	CLoadManagerTest();

	void ConstructL();

public:

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

	CLoadManager* iLoadManager;

	/** Unique Id of an interface implementation */

	TUid	iImplementationUid;

	/** LoadManager State Accessor */

	TLoadManager_StateAccessor iStateAccessor;

	};

/**

Standardised safe construction which

leaves nothing on the cleanup stack.

@post		CLoadManagerTest is fully constructed and initialised.

*/

CLoadManagerTest* CLoadManagerTest::NewL()

	{

	CLoadManagerTest* self = new(ELeave) CLoadManagerTest;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Standardized default constructor

@post		CLoadManagerTest is fully constructed.

*/

CLoadManagerTest::CLoadManagerTest()

	{

	// Implementation id for interface 0x10009DC0

	// Implemented in test plugin EComExample4.dll

	iImplementationUid.iUid		= 0x101F847A;

	}

/**

Destructor.

@post		This object is properly destroyed.

*/

CLoadManagerTest::~CLoadManagerTest()

	{

	delete iLoadManager;

	}

/**

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

@post		CLoadManagerTest is fully constructed.

*/

void CLoadManagerTest::ConstructL()

	{

	iLoadManager  =	CLoadManager::NewL();

	}

/**

The test executes by getting the Instantiation method for

the given ImplementationId

*/

void CLoadManagerTest::InstantiationMethodTestL(TUid aDllUid, const TDesC& aDllName, const TUid aIICType)

	{

	CExampleInterface::TExampleInterfaceInitParams iInitParams;

	iInitParams.integer		= 5;

	TBool initParamsFlag = ETrue;

	_LIT(KDummyText,"Dummy params");

	iInitParams.descriptor	= &KDummyText;

	TEntry entry;

	entry.iName=aDllName;

	entry.iModified=TTime(0);

	entry.iType=TUidType(KDynamicLibraryUid,aIICType,aDllUid);

	TAny* implementationPtr = 0;

	TUid instanceKey;

	TRAPD(err, implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid, entry,&iInitParams, initParamsFlag,instanceKey));

	::LeaveIfErrNoMemory(err);

	TEST2(err,KErrNone);

	TEST(implementationPtr != 0);

	//Checking the state of the arrays inside CLoadManager and garbage policy

	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==1);

	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==1);

	TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL);

	//Checking the instance index and UnloadPolicy info

	TEST(iStateAccessor.InstanceIndex(0,*iLoadManager)->ImplementationUid()==iImplementationUid);

	TEST(iStateAccessor.UnloadPolicy(0,*iLoadManager)->DllEntryInformation().GetName().CompareF(aDllName)==0);

	delete (CExampleInterface*)implementationPtr;

	implementationPtr=0;

	iLoadManager->DestroyedThis(instanceKey);

	iLoadManager->ClearGarbage();

	}

/**

Test CLoadManager::ImplementationObjectL with parameters to test old proxy table

*/

void CLoadManagerTest::InstantiationMethodTestPlugin1L()

	{

	// This test tests with Ecom plugin EComExample4.dll

	// EComExample4.dll should be installed on Z: drive

	// The test executes by getting the Instantiation method for the given ImplementationId

	// implementationPtr method should get some valid address.

	// Manually creating the DLL info that in practice will be returned from the server side

	// Set up some init params to be used for testing purpose

	TUid dllUid;

	dllUid.iUid = 0x101F8479;

	iImplementationUid.iUid=0x101F847A;

	InstantiationMethodTestL(dllUid,KExampleDllFileName4,KUidInterfaceImplementationCollection);

	}

/**

@SYMTestCaseID          SYSLIB-ECOM-UT-3549

@SYMTestCaseDesc	    Calls CLoadManager::ImplementationObjectL with parameters to test new proxy table

@SYMTestPriority 	    High

@SYMTestActions  	    Instantiate implementation for the given ImplementationId with construction parameters

						and check the CLoadManager data structures.

						Destroy the implementation object and again check the CLoadManager data structures.

						(ECom plugin EComExample10.dll will be used for the test.)

@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls

@SYMEC                  EC43

*/

void CLoadManagerTest::InstantiationMethodTestPlugin3L()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3549 "));

	TUid dllUid;

	dllUid.iUid = 0x10009E37;

	iImplementationUid.iUid = 0x10009E38;

	InstantiationMethodTestL(dllUid,KExampleDllFileName10,KUidInterfaceImplementationCollection3);

	}

/**

@SYMTestCaseID          SYSLIB-ECOM-UT-3710

@SYMTestCaseDesc	    Tests CLoadManager::ImplementationObjectL with some extreme conditions to improve the

						condition coverage rate.

						1. implementationUid is NULL. The function will leave with KErrNotFound

						2. dllName is NULL. The function will leave with KErrNotFound

						3. second Uid of the PlugIn is neither IIC or IIC3. The function will leave with KErrNotSupported

@SYMTestPriority 	    High

@SYMTestActions  	    Calls CLoadManager::ImplementationObjectL and check the result.

@SYMTestExpectedResults Expected error is return.

@SYMDEF                 DEF111196

*/

void CLoadManagerTest::ImplementationObjectTestL()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3710 "));

	TUid dummyUid;

	dummyUid.iUid = 0;

	TUid dllUid;

	dllUid.iUid = 0x10009E37;

	iImplementationUid.iUid = 0x10009E38;

	CExampleInterface::TExampleInterfaceInitParams iInitParams;

	iInitParams.integer		= 5;

	TBool initParamsFlag = ETrue;

	_LIT(KDummyText,"Dummy params");

	iInitParams.descriptor	= &KDummyText;

	TEntry entry;

	entry.iName=KExampleDllFileName10;

	entry.iModified=TTime(0);

	entry.iType=TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid);

	TUid instanceKey;

	// 1. Calls ImplementationObjectL with implementationUid is NULL. The function will leave with KErrNotFound

	TRAPD(err, TAny* implementationPtr = iLoadManager->ImplementationObjectL(dummyUid, entry,&iInitParams, initParamsFlag,instanceKey));

	TEST2(err,KErrNotFound);

	// 2. Calls ImplementationObjectL with dllName is NULL. The function will leave with KErrNotFound

	entry.iName = KNULLString;

	TRAP(err, TAny* implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid,entry,&iInitParams, initParamsFlag,instanceKey));

	TEST2(err,KErrNotFound);

	// 3. Calls ImplementationObjectL with second Uid of the PlugIn is neither IIC or IIC3

	entry.iName=KExampleDllFileName10;

	entry.iModified=TTime(0);

	entry.iType=TUidType(KDynamicLibraryUid,dummyUid,dllUid);

	TRAP(err, TAny* implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid,entry,&iInitParams, initParamsFlag,instanceKey));

	TEST2(err,KErrNotSupported);

	}

/**

Test CLoadManager::DestroyThis(). DestroyThis will actually either remove the UnloadPolicy from the list or decrease

referencecount(to UnloadPolicy) by one.

*/

void CLoadManagerTest::DestroyThisTestL(TUid aDllUid, const TDesC& aDllName, const TUid aIICType)

	{

	// We must call DestroyedThis only after getting a reference to the Implementation

	// so that reference count to this implementaion have value greater than zero.

	// ImplementationObjectL is called to increase the reference count of the test implementation,

	// so that its reference count goes to 1.

	// This test executes by verifing the reference count to this implementation.

	CExampleInterface::TExampleInterfaceInitParams iInitParams;

	iInitParams.integer		= 5;

	TBool initParamsFlag = ETrue;

	_LIT(KDummyText,"Dummy params");

	iInitParams.descriptor	= &KDummyText;

	TEntry entry;

	entry.iName=aDllName;

	entry.iModified=TTime(0);

	entry.iType=TUidType(KDynamicLibraryUid, aIICType, aDllUid);

	TAny* implementationPtr = 0;

	TUid instanceKey;

	TRAPD(err, implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid, entry, &iInitParams, initParamsFlag,instanceKey));

	::LeaveIfErrNoMemory(err);

	TEST2(err,KErrNone);

	TEST(implementationPtr != 0);

	//Checking the state of the arrays inside CLoadManager and the garbage policy

	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==1);

	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==1);

	TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL);

	// The purpose of DestroyedThis is to decrease the reference count of UnloadPolicy or

	// remove the Dll from RegistryData if its on grabagelist and reference count reaches 0

	iLoadManager->DestroyedThis(instanceKey);

	//Checking the state of the arrays inside CLoadManager and the garbage policy

	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==0);

	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==0);

	TEST(iStateAccessor.GarbagePolicy(*iLoadManager)!=NULL);

	//delete the instantiation

	delete (CExampleInterface*)implementationPtr;

	implementationPtr=0;

	}

/**

@SYMTestCaseID			SYSLIB-ECOM-UT-3709

@SYMTestCaseDesc		This testcase checks GetImplementationUidL().

@SYMTestPriority			High

@SYMTestActions			Instantiate an implementation.

						Call GetImplementationUidL() and check impl id.

						Call GetImplementationUidL() and check impl id again.

						Destroy plugin.

						Call GetImplementationUidL() and check for error.

@SYMTestExpectedResults	Returns impl uid when valid destructor uid is used otherwise

						leaves with the appropriate error.

@SYMDEF					DEF111789

*/

void CLoadManagerTest::GetImplementationUidTestL()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3709 "));

	// EComExample5.dll (dlluid 0x101F847B) in C:\  with Implementation Uid =0x101F847C

	TUid dllUid;

	dllUid.iUid = 0x101F847B;

	CExampleInterface::TExampleInterfaceInitParams iInitParams;

	iInitParams.integer		= 5;

	TBool initParamsFlag = ETrue;

	_LIT(KDummyText,"Dummy params");

	iInitParams.descriptor	= &KDummyText;

	TEntry entry;