// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <e32test.h>

#include <f32file.h>

#include <bautils.h>

#include <ecom/ecom.h>

#include <ecom/ecompanics.h>

#include "EComUidCodes.h"

#include "Interface.h" // interface to Plugins

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

//The tests test all the new APIs added to REComSession created for EC43

TUid KCExampleImplUid = {0x10009DC3};

const TInt KOneSecond = 1000000;

LOCAL_D RTest test(_L("t_extendedinterfaces"));

LOCAL_D RFs TheFs;

#define __UNUSED_VAR(var) var = var

// Used for OOM test

#define TEST_OOM_ERR if(err == KErrNoMemory) {User::Leave(err);}

static void ResetAndDestroyArray(TAny* aPtr)

	{

	(static_cast<RImplInfoPtrArray*>(aPtr))->ResetAndDestroy();

	}

/**

Test function for REcomSession::ListImplementationL

@param		aContainInvalidExtIf The bool value identifying if the extended interfaces list contains

			invalid extended interface Uid

@param		aUseDefResolver The bool value identifying if default resolver is used.

@param		aUseResolveParam The bool value identifying if resolve parameter is used.

@param		aNumEntriesInExtIFList The number of entries in the extended interfaces list.

@param		aImplInfoArray A reference to a client owned array which will be filled

			with interface implementation data.

*/

LOCAL_C void ListImplementationTestL(TBool aContainInvalidExtIf,

									 TBool aUseDefResolver,

									 TBool aUseResolveParam,

									 TInt aNumEntriesInExtIFList,

									 RImplInfoPtrArray& aImplInfoArray)

	{

	const TUid KInterfaceUid = {0x10009DBB};

	const TUid KExtendedInterfaceUid1 = {0x10009E44};

	const TUid KExtendedInterfaceUid2 = {0x10009E45};

	const TUid KExtendedInterfaceUid3 = {0x10009E46};

	const TUid KInvalidExtendedInterfaceUid2 = {0x10009E49};

	_LIT8(KExample10ImplementationTest,"Example 10");

	TUid resolverUid = {0x10009DD0};

	// Set up extended interfaces

	RArray<TUid> extendedInterfaces;

	CleanupClosePushL(extendedInterfaces);

	if (!aContainInvalidExtIf)

		{

		if (aNumEntriesInExtIFList==1)

			{

			extendedInterfaces.AppendL(KExtendedInterfaceUid1);

			}

		else if (aNumEntriesInExtIFList>1)

			{

			extendedInterfaces.AppendL(KExtendedInterfaceUid2);

			extendedInterfaces.AppendL(KExtendedInterfaceUid3);

			}

		}

	else

		{

		extendedInterfaces.AppendL(KExtendedInterfaceUid1);

		extendedInterfaces.AppendL(KInvalidExtendedInterfaceUid2);

		}

	//Set up resolve parameter

	TEComResolverParams ResolverParams;

	if (aUseResolveParam)

		{

		ResolverParams.SetDataType(KExample10ImplementationTest());

		ResolverParams.SetGenericMatch(ETrue);		// Allow wildcard matching

		if (aUseDefResolver) //ListImplementationTest2L,ListImplementationTest4L

			{

			REComSession::ListImplementationsL(KInterfaceUid,extendedInterfaces,ResolverParams,aImplInfoArray);

			}

		else //ListImplementationTest3L

			{

			REComSession::ListImplementationsL(KInterfaceUid,extendedInterfaces,ResolverParams,resolverUid,aImplInfoArray);

			}

		}

	else //ListImplementationTest1L, ListImplementationTest5L

		{

		REComSession::ListImplementationsL(KInterfaceUid,extendedInterfaces,aImplInfoArray);

		}

	CleanupStack::PopAndDestroy(&extendedInterfaces);

	}

/**

@SYMTestCaseID          SYSLIB-ECOM-CT-3597

@SYMTestCaseDesc	    Tests for CImplementationInformation structure.

@SYMTestPriority 	    High

@SYMTestActions  	    Call ListImplementationL method to get a list of implementations with extended interfaces.

						Check that the expected extended interfaces are available in the CImplementationInformation

						data structure via GetExtendedInterfaceList method.

@SYMTestExpectedResults Extended interfaces are available in implementation information structure.

@SYMEC                  EC43

*/

LOCAL_C void ListImplementationTest5L()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3597 "));

	// Test Starts...

	RImplInfoPtrArray ifArray;

	TBool containInvalidExtIf = EFalse;

	TBool useDefResolver = ETrue;

	TBool useResolveParam = EFalse;

	TInt numEntriesOnExtIFList = 3;

	ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);

	//Checks the result

	//0x10009E38 is implemented in EcomExample10.dll

	TUid KExample10ImplUid = {0x10009E38};

	TUid KExtendedInterfaceUid1 = {0x10009E44};

	TUid KExtendedInterfaceUid2 = {0x10009E45};

	TUid KExtendedInterfaceUid3 = {0x10009E46};

	const TInt availCount = ifArray.Count();

	test.Printf(_L("Found %d implementations.\n"),availCount);

	test(availCount == 1);

	//tests extended interfaces

	CImplementationInformation* info = ifArray[0];

	test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));

	test (KExample10ImplUid==info->ImplementationUid());

	CleanupStack::PushL(TCleanupItem(ResetAndDestroyArray, &ifArray));

	// Gets extended interfaces list

	RArray<TUid> extInf;

	CleanupClosePushL(extInf);

	info->GetExtendedInterfaceListL(extInf);

	test(extInf[0] == KExtendedInterfaceUid1);

	test(extInf[1] == KExtendedInterfaceUid2);

	test(extInf[2] == KExtendedInterfaceUid3);

	CleanupStack::PopAndDestroy(&extInf);

	// Empty the array of implementations

	test.Printf(_L("Destroying List..."));

	CleanupStack::PopAndDestroy(&ifArray);

	}

/**

@SYMTestCaseID          SYSLIB-ECOM-CT-3594

@SYMTestCaseDesc	    Tests for REComSession::ListImplementationL created with an Interface Uid

						and invalid extended Interfaces.

@SYMTestPriority 	    High

@SYMTestActions  	    Call ListImplementationL method supporting interface UID and extended interfaces

						that are invalid.

@SYMTestExpectedResults No implementation is returned.

@SYMEC                  EC43

*/

LOCAL_C void ListImplementationTest4L()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3594 "));

	// Test Starts...

	RImplInfoPtrArray ifArray;

	TBool containInvalidExtIf = ETrue;

	TBool useDefResolver = ETrue;

	TBool useResolveParam = ETrue;

	TInt numEntriesOnExtIFList = 2;

	ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);

	//Checks the result

	const TInt availCount = ifArray.Count();

	test.Printf(_L("Found %d implementations.\n"),availCount);

	test(availCount == 0);

	// Empty the array of implementations

	test.Printf(_L("Destroying List..."));

	ifArray.ResetAndDestroy();

	}

/**

@SYMTestCaseID          SYSLIB-ECOM-CT-3589

@SYMTestCaseDesc	    Tests for REComSession::ListImplementationsL for known Interface UID,

						resolver match characteristics, resolver UID and extended interfaces.

@SYMTestPriority 	    High

@SYMTestActions  	    Call ListImplementationL method supporting interface UID, resolver parameters

						resolver UID and extended interfaces.

@SYMTestExpectedResults Expected implementations are returned.

@SYMEC                  EC43

*/

LOCAL_C void ListImplementationTest3L()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3589 "));

	// Test Starts...

	RImplInfoPtrArray ifArray;

	TBool containInvalidExtIf = EFalse;

	TBool useDefResolver = EFalse;

	TBool useResolveParam = ETrue;

	//Number of entries in extended interfaces is 3.

	TInt numEntriesOnExtIFList = 3;

	ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);

	//Checks the result

	TUid KImplementationUid = {0x10009E38};

	TInt availCount = ifArray.Count();

	test.Printf(_L("Found %d implementations.\n"),availCount);

	test(availCount == 1);

	//tests implementation uid

	for (TInt count = 0; count < availCount; ++count)

		{

		const CImplementationInformation* info = ifArray[count];

		test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));

		test(KImplementationUid == info->ImplementationUid());

		}

	// Empty the array of implementations

	test.Printf(_L("Destroying List..."));

	ifArray.ResetAndDestroy();

	//Number of entries in extended interfaces is 0.

	numEntriesOnExtIFList = 0;

	ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);

	//Checks the result

	availCount = ifArray.Count();

	test.Printf(_L("Found %d implementations.\n"),availCount);

	test(availCount == 1);

	//tests implementation uid

	for (TInt count = 0; count < availCount; ++count)

		{

		const CImplementationInformation* info = ifArray[count];

		test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));

		}

	// Empty the array of implementations

	test.Printf(_L("Destroying List..."));

	ifArray.ResetAndDestroy();

	//Number of entries in extended interfaces is 1.

	numEntriesOnExtIFList = 1;

	ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);

	//Checks the result

	availCount = ifArray.Count();

	test.Printf(_L("Found %d implementations.\n"),availCount);

	test(availCount == 1);

	//tests implementation uid

	for (TInt count = 0; count < availCount; ++count)

		{

		const CImplementationInformation* info = ifArray[count];

		test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));

		}

	// Empty the array of implementations

	test.Printf(_L("Destroying List..."));

	ifArray.ResetAndDestroy();

	}

/**

@SYMTestCaseID          SYSLIB-ECOM-CT-3588

@SYMTestCaseDesc	    Tests for REComSession::ListImplementationsL for known Interface UID,

						resolver match characteristics and extended interfaces.

@SYMTestPriority 	    High

@SYMTestActions  	    Call ListImplementationL method supporting interface UID, resolver parameters and extended interfaces.

@SYMTestExpectedResults Expected implementations are returned.

@SYMEC                  EC43

*/

LOCAL_C void ListImplementationTest2L()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3588 "));

	// Test Starts...

	RImplInfoPtrArray ifArray;

	TBool containInvalidExtIf = EFalse;

	TBool useDefResolver = ETrue;

	TBool useResolveParam = ETrue;

	//Number of entries in extended interfaces is 3.

	TInt numEntriesOnExtIFList = 3;

	ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);

	//Checks the result

	TUid KImplementationUid = {0x10009E38};

	TInt availCount = ifArray.Count();

	test.Printf(_L("Found %d implementations.\n"),availCount);

	test(availCount == 1);

	//tests implementation uid

	for (TInt count = 0; count < availCount; ++count)

		{

		const CImplementationInformation* info = ifArray[count];

		test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));

		test(KImplementationUid==info->ImplementationUid());

		}

	// Empty the array of implementations

	test.Printf(_L("Destroying List..."));

	ifArray.ResetAndDestroy();

	//Number of entries in extended interfaces is 0.

	numEntriesOnExtIFList = 0;

	ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);

	//Checks the result

	availCount = ifArray.Count();

	test.Printf(_L("Found %d implementations.\n"),availCount);

	test(availCount == 1);

	//tests implementation uid

	for (TInt count = 0; count < availCount; ++count)

		{

		const CImplementationInformation* info = ifArray[count];

		test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));

		}

	// Empty the array of implementations

	test.Printf(_L("Destroying List..."));

	ifArray.ResetAndDestroy();

	//Number of entries in extended interfaces is 1.

	numEntriesOnExtIFList = 1;

	ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);

	//Checks the result

	availCount = ifArray.Count();

	test.Printf(_L("Found %d implementations.\n"),availCount);

	test(availCount == 1);

	//tests implementation uid

	for (TInt count = 0; count < availCount; ++count)

		{

		const CImplementationInformation* info = ifArray[count];

		test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));

		}

	// Empty the array of implementations

	test.Printf(_L("Destroying List..."));

	ifArray.ResetAndDestroy();

	}

/**

@SYMTestCaseID          SYSLIB-ECOM-CT-3587

@SYMTestCaseDesc	    Tests for REComSession::ListImplementationsL for known Interface UID and extended interfaces.

@SYMTestPriority 	    High

@SYMTestActions  	    Call ListImplementationL method supporting interface UID and extended interfaces.

@SYMTestExpectedResults Expected implementations are returned.

@SYMEC                  EC43

*/

LOCAL_C void ListImplementationTest1L()

	{

	//

	// Testing a overloaded method for ListImplementationsL

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

	//

	// Test Starts...

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3587 "));

	RImplInfoPtrArray ifArray;

	TBool containInvalidExtIf = EFalse;

	TBool useDefResolver = ETrue;

	TBool useResolveParam = EFalse;

	//Number of entries in extended interfaces is 3.

	TInt numEntriesOnExtIFList = 3;

	ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);

	//Checks the result

	//0x10009E38 is implemented in EcomExample10.dll

	TUid KExample10ImplUid = {0x10009E38};

	TInt availCount = ifArray.Count();

	test.Printf(_L("Found %d implementations.\n"),availCount);

	test(availCount == 1);

	//tests implementation uid

	const CImplementationInformation* info = ifArray[0];

	test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));

	test(KExample10ImplUid == info->ImplementationUid());

	// Empty the array of implementations

	test.Printf(_L("Destroying List..."));

	ifArray.ResetAndDestroy();

	//Number of entries in extended interfaces is 0.

	numEntriesOnExtIFList = 0;

	ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);

	//Checks the result

	availCount = ifArray.Count();

	test.Printf(_L("Found %d implementations.\n"),availCount);

	test(availCount == 3);

	//tests implementation uid

	for (TInt count = 0;count < availCount; ++count)

		{

		const CImplementationInformation* info = ifArray[count];

		test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));

		}

	// Empty the array of implementations

	test.Printf(_L("Destroying List..."));

	ifArray.ResetAndDestroy();

	//Number of entries in extended interfaces is 1.

	numEntriesOnExtIFList = 1;

	ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);

	//Checks the result

	availCount = ifArray.Count();

	test.Printf(_L("Found %d implementations.\n"),availCount);

	test(availCount == 2);

	//tests implementation uid

	for (TInt count = 0; count < availCount; ++count)

		{

		const CImplementationInformation* info = ifArray[count];

		test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));

		}

	// Empty the array of implementations

	test.Printf(_L("Destroying List..."));

	ifArray.ResetAndDestroy();

	}

/**

@SYMTestCaseID          SYSLIB-ECOM-CT-3713

@SYMTestCaseDesc	    Tests for REComSession::CreateImplementationL and REComSession::ListImplementationL

						with a dummy Interface Uid, dummy implementation Uid or dummy resolver Uid.

@SYMTestPriority 	    High

@SYMTestActions  	    Call CreateImplementationL method with a dummy interface UID

						Call CreateImplementationL method with a dummy implementation UID

						Call CreateImplementationL method with a dummy Resolver UID

						Call ListImplementationL method with a dummy interface UID

						Call ListImplementationL method with a dummy Resolver UID

@SYMTestExpectedResults Leave with KErrAugument and No implementation is created.

@SYMDEF                 DEF111196

*/

LOCAL_C void DummyUidTestL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3713 "));

	TUid instanceKey;

	TUid dummyUid;

	dummyUid.iUid = 0;

	const TUid KInterfaceUid = {0x10009DBB};

	const TUid KExample10InterfaceUid = {0x10009DBB};

	_LIT8(KExample10ImplementationTest,"Example 10");

	CExampleInterface* dllPtr = NULL;

	// Set up extended interfaces

	RArray<TUid> extendedInterfaces;

	CleanupClosePushL(extendedInterfaces);

	//Set up resolve parameter

	TEComResolverParams ResolverParams;

	ResolverParams.SetDataType(KExample10ImplementationTest());

	ResolverParams.SetGenericMatch(ETrue);		// Allow wildcard matching

	CExampleInterface::TExampleInterfaceInitParams initParams;

	// Set up some empty initialisation parameters

	initParams.integer		= 0;

	initParams.descriptor	= NULL;

	// CreateImplementationL with a dummy interface Uid

	TRAPD(err,dllPtr = REINTERPRET_CAST(CExampleInterface*,

				REComSession::CreateImplementationL(dummyUid,

													extendedInterfaces,

				  								    instanceKey,

												    ResolverParams,

												    &initParams)));

	test(err == KErrArgument);

	test(dllPtr == NULL);

	// CreateImplementationL with a dummy implementation Uid

	TRAP(err,dllPtr = REINTERPRET_CAST(CExampleInterface*,

				REComSession::CreateImplementationL(dummyUid,

				  								    instanceKey)));

	test(err == KErrArgument);

	test(dllPtr == NULL);

	// CreateImplementationL with a dummy resolver Uid

	TRAP(err, dllPtr = REINTERPRET_CAST(CExampleInterface*,

						REComSession::CreateImplementationL(KExample10InterfaceUid,

															extendedInterfaces,

														    instanceKey,

														    ResolverParams,

														    dummyUid,

														    &initParams)));

	test(err == KErrArgument);

	test(dllPtr == NULL);

	RImplInfoPtrArray ifArray;

	// ListImplementationL with a dummy interface Uid

	TRAP(err, REComSession::ListImplementationsL(dummyUid,extendedInterfaces,ResolverParams,ifArray));

	test(err == KErrArgument);

	test(ifArray.Count() == 0);

	// ListImplementationL with a dummy resolver Uid

	TRAP(err, REComSession::ListImplementationsL(KInterfaceUid,extendedInterfaces,ResolverParams,dummyUid,ifArray));

	test(err == KErrArgument);