// Copyright (c) 2005-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 tests for testing resolver related

 // functionality linking against ecom.lib, i.e. using public API

 // Where necessary stubs are implemented to help in writing test

 // harness using RTest.

 // This test assumes the following setup:

 // DLL			/Dll UID

 // EComExample /10009DB1 on Z:

 // EComExample2/10009DB3 on Z:

 // EComExample3/101F8477 on Z:

 // EComExample4/101F8479 on Z:

 // EComExample5/101F847B on C:

 // Suicidal    /10009DB2 on Z:

 // EComExample6/0x101F847D on Z:

 // The tests work by checking that the correct implementations are chosen

 // for interface 0x10009DC0 depending on parameters passed

 // Implementations:

 // Impl ID		On C:		On Z: e.g:Version/Default_data/dll_uid

 // 10009DC3	-			Ver 1/"text/ wml"/10009DB1, Ver 2/"text/ wml"/10009DB3

 // 10009DC4	-			Ver 1/"text/ *"/10009DB1,   Ver 2/"text/ *"/10009DB3

 // 101F8478	-			Ver 1/""/101F8477

 // 101F847A	-			Ver 1/""/101F8479

 // 101F847C	Ver 1/""/101F847B	-

 // 10009DC5	-			Ver 1/"Suicide"/10009DB2

 // 101F847E	on Z		Ver 1/""/101F847D

 // 

 //

 #include <ecom/ecom.h>

 #include "EComUidCodes.h"

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

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

 #include <e32test.h>

 #include <f32file.h>

 #include <bautils.h>

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

 LOCAL_D CTrapCleanup* 	  TheTrapCleanup 	 = NULL;

 LOCAL_D CActiveScheduler* TheActiveScheduler = NULL;

 // Used for supressing warning in OOM tests

 #define __UNUSED_VAR(var) var = var

 const TInt KOneSecond		= 1000000;

 // Interface ID used for testing

 const TUid KUidInterface	= {0x10009DC0};

 // Resolver ID used for testing

 const TUid KUidResolver		= {0x10009DD0};

 // Implementaion ID used for testing

 const TUid KUidTestImplementation = {0x10009DC5};

 // Interface Implementation Uids used for testing

 const TInt KUidImplementation1 = 0x10009DC3;

 const TInt KUidImplementation2 = 0x10009DC4;

 const TInt KUidImplementation3 = 0x10009DC5;

 const TInt KUidImplementation4 = 0x101F8478;

 const TInt KUidImplementation5 = 0x101F847A;

 const TInt KUidImplementation6 = 0x101F847C;

 const TInt KUidImplementation7 = 0x101F847E;

 // Match string used for testing

 _LIT8(KInterfaceResolveMatchStr,"suicidal");

 _LIT(KSysBinDirectoryWildcard, "c:\\sys\\bin\\*.dll");

 _LIT(KResourceDirectoryWildcard, "c:\\resource\\plugins\\*.rsc");

 // Plugins used for this test program

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

 _LIT(KEComExample5OnC,		"c:\\sys\\bin\\EComExample5.dll");

 _LIT(KEComExample5RscOnC,	"c:\\resource\\plugins\\EComExample5.rsc");

 _LIT(KEComExample4OnC,		"c:\\sys\\bin\\EComExample4.dll");

 _LIT(KEComExample4RscOnC,	"c:\\resource\\plugins\\EComExample4.rsc");

 // ROM file copied to the RAM for test purposes

 _LIT(KEComExample5RscOnZ,	"z:\\RAMOnly\\EComExample5.rsc");

 // Utility clean up function

 LOCAL_C void CleanupEComArray(TAny* aArray);

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

 //from normal test and from OOM test.

 static void LeaveIfErrNoMemory(TInt aError)

 	{

 	if(aError == KErrNoMemory)

 		{

 		REComSession::FinalClose();

 		User::Leave(aError);

 		}

 	}

 /**

 @SYMTestCaseID          SYSLIB-ECOM-CT-0709

 @SYMTestCaseDesc	    Tests for creation of plugin with resolver match string

 @SYMTestPriority 	    High

 @SYMTestActions  	    Checks for no error condition

 @SYMTestExpectedResults The test must not fail.

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestCreateImplSuicideL()

 	{

 	// Tests creation of plugin with resolver match string

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

 	/* This should pick

 	10009DC5	Ver 1/"Suicide"/10009DB2

 	*/

 	CExampleInterface* interfaceimpl = NULL;

 	TRAPD(err, interfaceimpl = CExampleInterface::NewL(KInterfaceResolveMatchStr()));

 	::LeaveIfErrNoMemory(err);

 	test(err == KErrNone);

 	CleanupStack::PushL(interfaceimpl);

 	test(KUidTestImplementation == interfaceimpl->ImplId());

 	TRAP(err, interfaceimpl->DoMethodL());

 	::LeaveIfErrNoMemory(err);

 	test(err == KErrNone);

 	CleanupStack::PopAndDestroy(interfaceimpl);

 	}

 /**

 @SYMTestCaseID          SYSLIB-ECOM-CT-0710

 @SYMTestCaseDesc	    Tests for Listing all Implementations for the Interface KUidInterface

 @SYMTestPriority 	    High

 @SYMTestActions  	    Calls up REComSession::ListImplementationsL with interface UID.Picks up 6 implementations.

                         Checks for no memory exceptions.

 @SYMTestExpectedResults The test must not fail.

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestListAllImplL()

 	{

 	// Test for Listing all Implementations for the Interface KUidInterface

 	//

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

 	RImplInfoPtrArray ifArray;

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

 	TRAPD(err, REComSession::ListImplementationsL(KUidInterface, ifArray));

 	::LeaveIfErrNoMemory(err);

 	test(err == KErrNone);

 	/* This should pick 6 implementations given below

 	10009DC3	Ver 2/"text/ wml"/10009DB3

 	10009DC4	Ver 2/"text/ *"/10009DB3

 	101F8478	Ver 1/""/101F8477

 	101F847A	Ver 1/""/101F8479

 	101F847C	Ver 1/""/101F847B

 	10009DC5	Ver 1/"Suicide"/10009DB2

 	101F847E	Ver 1/""/101F847D

 	*/

 	const TInt availCount = ifArray.Count();

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

 	test(availCount == 7);

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

 		{

 		const CImplementationInformation* info = ifArray[count];

 		TDriveName driveName = info->Drive().Name();

 		test.Printf(_L("%d. uid={%x} version=%d on drive %S\n"), count+1, info->ImplementationUid(), info->Version(), &driveName);

 		switch(info->ImplementationUid().iUid)

 			{

 			case KUidImplementation1:

 				test(info->Version()==2);

 				test(info->Drive()==EDriveZ);

 				break;

 			case KUidImplementation2:

 				test(info->Version()==2);

 				test(info->Drive()==EDriveZ);

 				break;

 			case KUidImplementation3:

 				test(info->Version()==1);

 				test(info->Drive()==EDriveZ);

 				break;

 			case KUidImplementation4:

 				test(info->Version()==1);

 				test(info->Drive()==EDriveZ);

 				break;

 			case KUidImplementation5:

 				test(info->Version()==1);

 				test(info->Drive()==EDriveZ);

 				break;

 			case KUidImplementation6:

 				test(info->Version()==1);

 				test(info->Drive()==EDriveC);

 				break;

 			case KUidImplementation7:

 				test(info->Version()==1);

 				test(info->Drive()==EDriveZ);

 				break;

 			default:

 				test.Printf(_L("Unknown implementation Uid\n"));

 				test(EFalse);

 			}

 		}

 	// Empty the array of implementations

 	CleanupStack::PopAndDestroy();//ifArray, results in a call to CleanupEComArray

 	}

 /**

 @SYMTestCaseID          SYSLIB-ECOM-CT-0711

 @SYMTestCaseDesc	    Tests to list all implementations for an interface with specified

 						match string and wildcard match

 @SYMTestPriority 	    High

 @SYMTestActions  	    Calls up REComSession::ListImplementationsL with interface UID and resolver matching characteristics

                         Checks for no memory exceptions.

 @SYMTestExpectedResults The test must not fail.

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestListImplMatchStrWildcardL()

 	{

 	// Test to list all implementations for an interface with match string

 	// and wildcard match

 	//

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

 	TEComResolverParams resolverParams;

 	_LIT8(KImplementationTest,"text/wml");

 	resolverParams.SetDataType(KImplementationTest());//Match string

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

 	RImplInfoPtrArray ifArray;

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

 	TRAPD(err, REComSession::ListImplementationsL(KUidInterface, resolverParams, ifArray));

 	::LeaveIfErrNoMemory(err);

 	test(err == KErrNone);

 	/* This should pick 2 implementations given below

 	10009DC3	Ver 2/"text/ wml"/10009DB3

 	10009DC4	Ver 2/"text/ *"/10009DB3

 	*/

 	const TInt availCount = ifArray.Count();

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

 	test(availCount == 2);

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

 		{

 		const CImplementationInformation* info = ifArray[count];

 		TDriveName driveName = info->Drive().Name();

 		test.Printf(_L("%d. uid={%x} version=%d on drive %S\n"), count+1, info->ImplementationUid(), info->Version(), &driveName);

 		switch(info->ImplementationUid().iUid)

 			{

 			case KUidImplementation1:

 				test(info->Version()==2);

 				test(info->Drive()==EDriveZ);

 				break;

 			case KUidImplementation2:

 				test(info->Version()==2);

 				test(info->Drive()==EDriveZ);

 				break;

 			default:

 				test.Printf(_L("Unknown implementation UID\n"));

 				test(EFalse);

 			}

 		}

 	// Empty the array of implementations

 	CleanupStack::PopAndDestroy();//ifArray, results in a call to CleanupEComArray

 	}

 /**

 @SYMTestCaseID          SYSLIB-ECOM-CT-0712

 @SYMTestCaseDesc	    Tests to list all implementations for an interface with specified

 						match string and no wildcard match

 @SYMTestPriority 	    High

 @SYMTestActions  	    Calls up REComSession::ListImplementationsL with interface UID and resolver matching characteristics

                         Checks for no memory exceptions.

 @SYMTestExpectedResults The test must not fail.

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestListImplMatchStrL()

 	{

 	// Test to list all implementations for an interface with specified

 	// match string and no wildcard match

 	//

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

 	TEComResolverParams resolverParams;

 	_LIT8(KImplementationTest,"text/wml");

 	resolverParams.SetDataType(KImplementationTest());//Match string

 	resolverParams.SetGenericMatch(EFalse);	// Don't allow wildcard matching

 	RImplInfoPtrArray ifArray;

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

 	TRAPD(err, REComSession::ListImplementationsL(KUidInterface, resolverParams, ifArray));

 	::LeaveIfErrNoMemory(err);

 	test(err == KErrNone);

 	const TInt availCount = ifArray.Count();

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

 	test(availCount == 1);

 	/* This should pick

 	10009DC3	Ver 2/"text/wml"/10009DB3

 	*/

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

 		{

 		const CImplementationInformation* info = ifArray[count];

 		TDriveName driveName = info->Drive().Name();

 		test.Printf(_L("%d. uid={%x} version=%d on drive %S\n"),

 					count+1, info->ImplementationUid(), info->Version(), &driveName);

 		switch(info->ImplementationUid().iUid)

 			{

 			case KUidImplementation1:

 				test(info->Version()==2);

 				test(info->Drive()==EDriveZ);

 				break;

 			default:

 				test.Printf(_L("Unknown implementation Uid\n"));

 				test(EFalse);

 			}

 		}

 	// Empty the array of implementations

 	CleanupStack::PopAndDestroy();//ifArray, results in a call to CleanupEComArray

 	}

 /**

 @SYMTestCaseID          SYSLIB-ECOM-CT-0713

 @SYMTestCaseDesc	    Tests to list all Implementations for an Interface with specified

 						Resolver ID, Match String and Wildcard match

 @SYMTestPriority 	    High

 @SYMTestActions  	    Calls up REComSession::ListImplementationsL with interface UID Resolver ID, matching characteristics

                         Checks for no memory exceptions.

 @SYMTestExpectedResults The test must not fail.

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestListAllImplResolverIDL()

 	{

 	// Test to list all Implementations for an Interface with specified

 	// Resolver ID, Match String and Wildcard match

 	//

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

 	TEComResolverParams resolverParams;

 	resolverParams.SetDataType(KInterfaceResolveMatchStr());

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

 	RImplInfoPtrArray ifArray;

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

 	TRAPD(err, REComSession::ListImplementationsL(KUidInterface,

 												  resolverParams,

 												  KUidResolver,

 												  ifArray));

 	::LeaveIfErrNoMemory(err);

 	test(err == KErrNone);

 	const TInt availCount = ifArray.Count();

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

 	test(availCount == 1);

 	/* This should pick

 	10009DC5	Ver 1/"Suicide"/10009DB2

 	*/

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

 		{

 		const CImplementationInformation* info = ifArray[count];

 		TDriveName driveName = info->Drive().Name();

 		test.Printf(_L("%d. uid={%x} version=%d on drive %S\n"), count+1, info->ImplementationUid(), info->Version(), &driveName);

 		switch(info->ImplementationUid().iUid)

 			{

 			case KUidImplementation3:

 				test(info->Version()==1);

 				test(info->Drive()==EDriveZ);

 				break;

 			default:

 				test.Printf(_L("Unknown implementation UID\n"));

 				test(EFalse);

 			}

 		}

 	// Empty the array of implementations

 	CleanupStack::PopAndDestroy();//ifArray, results in a call to CleanupEComArray

 	}

 typedef void (*ClassFuncPtrL) (void);

 /**

 @SYMTestCaseID          SYSLIB-ECOM-CT-0714

 @SYMTestCaseDesc	    Function to call all test functions

 @SYMTestPriority 	    High

 @SYMTestActions  	    Calls up test function and checks for handle counts.

 @SYMTestExpectedResults The test must not fail.

 @SYMREQ                 REQ0000

 */

 /**

 Wrapper function to call all test functions

 @param		testFuncL pointer to test function

 @param		aTestDesc test function name

 */

 LOCAL_C void DoBasicTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc)

 	{

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

 	test.Next(aTestDesc);

 	__UHEAP_MARK;

   	// find out the number of open handles

 	TInt startProcessHandleCount;

 	TInt startThreadHandleCount;

 	RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

 	//Call the test function

 	(*testFuncL)();

 	REComSession::FinalClose();

 	// check that no handles have leaked

 	TInt endProcessHandleCount;

 	TInt endThreadHandleCount;

 	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

 	test(startThreadHandleCount  == endThreadHandleCount);

 	__UHEAP_MARKEND;

 	}

 /**

 @SYMTestCaseID          SYSLIB-ECOM-CT-0715

 @SYMTestCaseDesc	    Wrapper function to call all OOM test functions

 @SYMTestPriority 	    High

 @SYMTestActions  	    Calls up test function and checks for handle counts.

 @SYMTestExpectedResults The test must not fail.

 @SYMREQ                 REQ0000

 */

 /**

 Wrapper function to call all OOM test functions

 @param		testFuncL pointer to OOM test function

 @param		aTestDesc test function name

 */

 LOCAL_C void DoOOMTest(ClassFuncPtrL testFuncL, const TDesC& aTestDesc)

 	{

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

 	test.Next(aTestDesc);

 	TInt err, tryCount = 0;

 	do

 		{

 		__UHEAP_MARK;

   		// find out the number of open handles

 		TInt startProcessHandleCount;

 		TInt startThreadHandleCount;

 		RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

 		// Setting Heap failure for OOM test

 		__UHEAP_SETFAIL(RHeap::EDeterministic, ++tryCount);

 		TRAP(err, (*testFuncL)());

 		__UHEAP_SETFAIL(RHeap::ENone, 0);

 		// release handles

 		if(err == KErrNone)

 			{

 			REComSession::FinalClose();

 			}

 		// check that no handles have leaked

 		TInt endProcessHandleCount;

 		TInt endThreadHandleCount;

 		RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

 		test(startProcessHandleCount == endProcessHandleCount);

 		test(startThreadHandleCount  == endThreadHandleCount);

 		__UHEAP_MARKEND;

 		} while(err == KErrNoMemory);

 	test(err == KErrNone);

 	test.Printf(_L("- server succeeded at heap failure rate of %i\n"), tryCount);

 	}

 LOCAL_C void DoTestsL()

 	{

 	__UHEAP_MARK;

 	// Basic tests

 	DoBasicTestL(TestCreateImplSuicideL, _L("TestCreateImplSuicideL"));

 	DoBasicTestL(TestListImplMatchStrL, _L("TestListImplMatchStrL"));

 	DoBasicTestL(TestListImplMatchStrWildcardL, _L("TestListImplMatchStrWildcardL"));

 	DoBasicTestL(TestListAllImplL, _L("TestListAllImplL"));

 	DoBasicTestL(TestListAllImplResolverIDL, _L("TestListAllImplResolverIDL"));

 	// OOM tests

 	DoOOMTest(TestCreateImplSuicideL, _L("OOM TestCreateImplSuicide"));

 	DoOOMTest(TestListImplMatchStrL, _L("OOM TestListImplMatchStr"));

 	DoOOMTest(TestListImplMatchStrWildcardL, _L("OOM TestListImplMatchStrWildcard"));

 	DoOOMTest(TestListAllImplL, _L("OOM TestListAllImpl"));

 	DoOOMTest(TestListAllImplResolverIDL, _L("OOM TestListAllImplResolverID"));

 	__UHEAP_MARKEND;

 	}

 // This function is used for cleanup support of locally declared arrays

 LOCAL_C void CleanupEComArray(TAny* aArray)

 	{

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

 	}

 // Deleting plugin from the RAM for cleanup purpose

 inline LOCAL_C void DeleteTestPlugins()

 	{

 	TRAPD(err, EComTestUtils::FileManDeleteFileL(KSysBinDirectoryWildcard));

 	TRAP(err, EComTestUtils::FileManDeleteFileL(KResourceDirectoryWildcard));

 	}

 // Copies the Plugins to specific folder for testing purpose

 LOCAL_C void CopyPlugins()

 	{

 	DeleteTestPlugins();

 	TRAPD(err, EComTestUtils::FileManCopyFileL(KEComExample5OnZ, KEComExample5OnC));

 	test(err==KErrNone);

 	TRAP(err, EComTestUtils::FileManCopyFileL(KEComExample5RscOnZ, KEComExample5RscOnC));

 	test(err==KErrNone);

 	// KEComExample4OnC & KEComExample4RscOnC are copied to C: Drive for

 	// testing in t_listimplementation test program. These files should

 	// be present in Z:. Please make sure these are present in Z only.

 	TRAP(err, EComTestUtils::FileManDeleteFileL(KEComExample4OnC));

 	TRAP(err, EComTestUtils::FileManDeleteFileL(KEComExample4RscOnC));

 	}

 //Initialise the Active Scheduler

 //

 LOCAL_C void SetupL()

 	{

 	// Construct and install the Active Scheduler. The Active Schedular is needed

 	// by components used by this test as they are ActiveObjects.

 	TheActiveScheduler = new(ELeave)CActiveScheduler;

 	CActiveScheduler::Install(TheActiveScheduler);

 	}

 GLDEF_C TInt E32Main()

 	{

 	__UHEAP_MARK;

 	test.Printf(_L("\n"));

 	test.Title();

 	test.Start(_L("Suicide Tests"));

 	TheTrapCleanup = CTrapCleanup::New();

 	TRAPD(err, SetupL());

 	test(err == KErrNone);

 	CopyPlugins();

 	// The reason for the folowing delay is:

 	// ECOM server could be already started. It means that when we copy some

 	// ECOM plugins from Z: to C: drive - ECOM server should look for and

 	// find the new ECOM plugins. The ECOM server uses for that an active object,

 	// which scans plugin directories. So the discovering service is asynchronous.

 	// We have to wait some time until it finishes.

 	// Otherwise ListImplementationsL could fail to find requested implementations.

 	User::After(KOneSecond * 3);

 	TRAP(err,DoTestsL());

 	test(err==KErrNone);

 	// Cleanup files. If the cleanup fails that is no problem,

 	// as any subsequent tests will replace them. The only downside

 	// would be the disk not being tidied

 	DeleteTestPlugins();

 	delete TheActiveScheduler;

 	delete TheTrapCleanup;

 	test.End();

 	test.Close();

 	__UHEAP_MARKEND;

 	return (KErrNone);

 	}