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

// Contains tests with invalid/missing plugin DLLs

// 

//

#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_plugindiscovery.exe"));

LOCAL_D CTrapCleanup* 	  TheTrapCleanup 	 = NULL;

LOCAL_D CActiveScheduler* TheActiveScheduler = NULL;

LOCAL_D RFs					TheFs;

// Implementaion ID used for testing

const TUid KUidTestImplementation = {0x101F847C};

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

		}

	}

// Plugins used in tests.

_LIT(KEComInvalidDllOnZ, "z:\\RAMOnly\\InvalidSIDPlugin.dll");

_LIT(KEComInvalidRscOnZ, "z:\\RAMOnly\\InvalidSIDPlugin.rsc");

_LIT(KEComInvalidDllOnC, "c:\\sys\\bin\\InvalidSIDPlugin.dll");

_LIT(KEComInvalidRscOnC, "c:\\resource\\plugins\\InvalidSIDPlugin.rsc");

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

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

_LIT(KEComRomRslvrExampleRscOnCRomLocation, "z:\\RAMOnly\\EComRomRslvrExampleOnC.RSC");

_LIT(KEComRomRslvrExampleRscOnCRamLocation, "c:\\resource\\plugins\\EComRomRslvrExampleOnZ.RSC");

// Plugins used in plugins directory removing test

_LIT(KEComDefectPluginDLLOnZ,			"Z:\\RAMOnly\\DefectPlugin.dll");

_LIT(KEComDefectPluginRSCOnZ,			"Z:\\RAMOnly\\DefectPlugin.rsc");

_LIT(KEComDefectPluginDLLOnC,			"C:\\sys\\bin\\DefectPlugin.dll");

_LIT(KEComDefectPluginRSCOnC,			"C:\\Resource\\Plugins\\DefectPlugin.rsc");

_LIT(KEComResourcePluginDirNameOnC,		"C:\\Resource\\Plugins\\");

_LIT(KEComResourcePluginDirNameOffOnC,	"C:\\Resource\\PluginsNameOff\\");

/**

@SYMTestCaseID SYSLIB-ECOM-CT-0030

@SYMTestCaseDesc Test that an orphaned resource file does not create a registry

				 entry.

@SYMTestPriority High

@SYMTestActions  EComExample5.rsc file copied to C: drive.

				 Check call to REComSession::CreateImplementationL() via test

				 CExampleInterface class fails to return the implementation.

@SYMTestExpectedResults The test must not fail.

@SYMREQ REQ3846

*/

LOCAL_C void TestOrphanedRscFileL()

	{

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

	__UHEAP_MARK;

	// Copy plugin

	TRAPD(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComExample5RscOnC));

	ignoreErr = ignoreErr;

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

	test(err == KErrNone);

	// 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 CreateImplementationsL could fail to create requested implementations.

	WAIT_FOR3s;

	CExampleInterface* interfaceimpl = NULL;

	TRAP(err, interfaceimpl = CExampleInterface::NewL2(KUidTestImplementation));

	::LeaveIfErrNoMemory(err);

	test(err == KErrNotFound);

	CleanupStack::PushL(interfaceimpl);

	CleanupStack::PopAndDestroy(interfaceimpl);

	REComSession::FinalClose();

	// Delete plugin

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

	test(err == KErrNone);

	__UHEAP_MARK;

	}

/**

@SYMTestCaseID SYSLIB-ECOM-CT-1404

@SYMTestCaseDesc Test that an orphaned resource file does not create a registry entry.

			and that other valid implementations are discovered instead.

@SYMTestPriority High

@SYMTestActions  Copy EComRomRslvrExampleOnC to the plug-ins directory on the C drive, without the associated DLL

	Because the DLL is not there, Ecom should fall back to the implementations on the Z drive in EComRomRslvrExampleOnZ

@SYMTestExpectedResults ECom plugins with invalid DLLs fall back to the correct implementations.

@SYMPREQ	PREQ1192

*/

LOCAL_C void TestOrphanedRscFileFallBackL()

	{

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

	__UHEAP_MARK;

	// Copy plugin resource file and NOT the associated DLL

	TRAPD(err, EComTestUtils::FileManCopyFileL(KEComRomRslvrExampleRscOnCRomLocation, KEComRomRslvrExampleRscOnCRamLocation));

	test(err == KErrNone);

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

	WAIT_FOR3s;

	TUid romRslvrExampleInterfaceUid = {0x10009DC8};

	RImplInfoPtrArray ifArray;

	TRAP(err, REComSession::ListImplementationsL(romRslvrExampleInterfaceUid, ifArray));

	::LeaveIfErrNoMemory(err);

	test(err == KErrNone);

	// Go through the implementations for the given interface, and find the ones that match up with

	// EComRomRslvrExampleRscOnZ (and not EComRomRslvrExampleRscOnC becuase it's DLL is missing)

	// EComRomRslvrExampleOnZ contains the implementation 0x10009DC7v2 and 0x10009DC6v1 (these should be found)

	// EComRomRslvrExampleOnC contains the implementation 0x10009DC7v1 and 0x10009DC6v2 (these should NOT be returned becuase of the missing DLL)

	TBool foundRightImplementation1 = EFalse;

	TBool foundRightImplementation2 = EFalse;

	for(TInt index = 0; index < ifArray.Count(); ++index)

		{

		TUid uid = ifArray[index]->ImplementationUid();

		TInt version = ifArray[index]->Version();

		TInt drive = ifArray[index]->Drive();

		if (uid.iUid == 0x10009DC6)

			{

			test(version == 1);

			test(drive==EDriveZ);

			foundRightImplementation1 = ETrue;

			}

		if (uid.iUid == 0x10009DC7)

			{

			test(version == 2);

			test(drive==EDriveZ);

			foundRightImplementation2 = ETrue;

			}

		}

	test(foundRightImplementation1 && foundRightImplementation2);

	ifArray.ResetAndDestroy();

	REComSession::FinalClose();

	// Delete plugin

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

	test(err == KErrNone);

	__UHEAP_MARK;

	}

/**

@SYMTestCaseID SYSLIB-ECOM-CT-0031

@SYMTestCaseDesc Test that a plugin whose SID does not match the value in it's

				 resource file will not be installed in the registry.

@SYMTestPriority High

@SYMTestActions  InvalidSIDPlugin dll and rsc files copied to C: drive.

				 Verify plugin is not registered by checking

				 ListImplementationsL returns zero plugins for this interface.

@SYMTestExpectedResults The test must not fail.

@SYMREQ REQ3846

*/

LOCAL_C void TestInvalidSIDPluginL()

	{

	// InvalidSIDPlugin .dll and .rsc are copied from EComExample5.dll and

	// HeapTestImpl.rsc.

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

	__UHEAP_MARK;

	// Copy plugins

	TRAPD(err, EComTestUtils::FileManCopyFileL(KEComInvalidDllOnZ, KEComInvalidDllOnC));

	test(err == KErrNone);

	TRAP(err, EComTestUtils::FileManCopyFileL(KEComInvalidRscOnZ, KEComInvalidRscOnC));

	test(err == KErrNone);

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

	WAIT_FOR3s;

	TUid ifUid = {0x101FE392};  // HeapTestImpl.rsc interface_uid

	RImplInfoPtrArray ifArray;

	REComSession::ListImplementationsL(ifUid, ifArray);

	const TInt availCount = ifArray.Count();

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

	test(availCount == 0);

	ifArray.ResetAndDestroy();

	REComSession::FinalClose(); // Don't want leaks outside the test

	// Cleanup plugins

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

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

	__UHEAP_MARK;

	}

/**

@SYMTestCaseID SYSLIB-ECOM-CT-1858

@SYMTestCaseDesc Test that rediscovery of removing and adding "\Resource\Plugins" directory

					works properly.

@SYMTestPriority High

@SYMTestActions  Removes "\Resource\Plugins" directory on C: drive, check that

					rediscovery	works properly by verifying plugin's registration.

				 Adds "\Resource\Plugins" directory on C: drive, check that rediscovery works

				 	fine by verifying plugin's registration.

@SYMTestExpectedResults The test must not fail.

@SYMDEF DEF088454

*/

LOCAL_C void TestPluginsDirectoryRemovingL()

	{

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

	__UHEAP_MARK;

	/**

	Add The following plugin to C drive

	Interface UID		DLL	UID		Imp. UID		Version		DllFile

	------------------------------------------------------------------------------------------------------------------------------------------

	0x102797A1			0x102797A0	0x102797A2		1			C:\\..\\DefectPlugin.dll

	**/

	TRAPD(err, EComTestUtils::FileManCopyFileL(KEComDefectPluginDLLOnZ, KEComDefectPluginDLLOnC));

	test(err == KErrNone);

	TRAP(err, EComTestUtils::FileManCopyFileL(KEComDefectPluginRSCOnZ, KEComDefectPluginRSCOnC));

	test(err == KErrNone);

	WAIT_FOR3s;

	TUid interfaceUid={0x102797A1};

	RImplInfoPtrArray implArray;

	// Now start ecom discovery and get implementations for IF UID 0x102797A1

	TRAP(err, REComSession::ListImplementationsL(interfaceUid, implArray));

	::LeaveIfErrNoMemory(err);

	test(err == KErrNone);

	// Expected number of implementations returned

	test(implArray.Count()==1);

	// Check that the implementation uid returned matched the specs above

	TUid implUid = implArray[0]->ImplementationUid();

	TInt version = implArray[0]->Version();

	TInt drive = implArray[0]->Drive();

	// imp. uid

	test(implUid.iUid == 0x102797A2);

	// version

	test(version == 1);

	// C drive

	test(drive == EDriveC);

	implArray.ResetAndDestroy();

	// Now remove plugins directory

	TRAP(err, EComTestUtils::FileManRenameL(KEComResourcePluginDirNameOnC, KEComResourcePluginDirNameOffOnC));

	test(err == KErrNone);

	TRAP(err, EComTestUtils::FileManDeleteDirL(KEComResourcePluginDirNameOnC));

	test(err == KErrNone);

	TEntry entry;

	err = TheFs.Entry(KEComResourcePluginDirNameOnC, entry);

	// Test the plugins directory is now gone

	test(err == KErrNotFound);

	// Wait EComServer performing rediscovery

	WAIT_FOR3s;

	TRAP(err, REComSession::ListImplementationsL(interfaceUid, implArray));

	::LeaveIfErrNoMemory(err);

	test(err == KErrNone);

	// Test the rediscovery and directory scanning has been performed on renaming off event

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

	implArray.ResetAndDestroy();

	// Now rename plugins directory back

	TRAP(err, EComTestUtils::FileManRenameL(KEComResourcePluginDirNameOffOnC, KEComResourcePluginDirNameOnC));

	test(err == KErrNone);

	TRAP(err, EComTestUtils::FileManDeleteDirL(KEComResourcePluginDirNameOffOnC));

	test(err == KErrNone);

	// Test the plugins directory is added back

	err = TheFs.Entry(KEComResourcePluginDirNameOnC, entry);

	test(err == KErrNone);

	// Wait EComServer performing rediscovery

	WAIT_FOR3s;

	TRAP(err, REComSession::ListImplementationsL(interfaceUid, implArray));

	::LeaveIfErrNoMemory(err);

	test(err == KErrNone);

	// Test the rediscovery and directory scanning has been performed on renaming off event

	test(implArray.Count()==1);

	//Check that the implementation uid returned matched the specs above

	implUid = implArray[0]->ImplementationUid();

	version = implArray[0]->Version();

	drive = implArray[0]->Drive();

	test(implUid.iUid == 0x102797A2);

	test(version == 1);

	test(drive == EDriveC);

	implArray.ResetAndDestroy();

	REComSession::FinalClose(); // Don't want leaks outside the test

	// Cleanup plugins

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

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

	__UHEAP_MARK;

	}

typedef void (*ClassFuncPtrL) (void);

/**

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(aTestDesc);

	__UHEAP_MARK;

  	// find out the number of open handles

	TInt startProcessHandleCount;

	TInt startThreadHandleCount;

	RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

	//Call the test function

	(*testFuncL)();

	// check that no handles have leaked

	TInt endProcessHandleCount;

	TInt endThreadHandleCount;

	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

	test(startThreadHandleCount  == endThreadHandleCount);

	__UHEAP_MARKEND;

	}

/**

Wrapper function to call all OOM test functions

@param		testFuncL pointer to OOM test function

@param		aTestDesc test function name

*/

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

	{

	test.Next(aTestDesc);

	TInt err;

	TInt tryCount = 0;

	do

		{

		__UHEAP_MARK;

  		// find out the number of open handles

		TInt startProcessHandleCount;

		TInt startThreadHandleCount;

		RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

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

		//Call the test function

		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

	test.Next(_L("Basic Test Suite"));

	test.Start(_L("Basic Test Suite"));

	DoBasicTestL(&TestOrphanedRscFileL, _L("TestOrphanedRscFileL"));

	DoBasicTestL(&TestInvalidSIDPluginL, _L("TestInvalidSIDPluginL"));

	DoBasicTestL(&TestOrphanedRscFileFallBackL, _L("TestOrphanedRscFileFallBackL"));

	DoBasicTestL(&TestPluginsDirectoryRemovingL, _L("TestPluginsDirectoryRemovingL"));

	test.End();

	// OOM tests

	test.Next(_L("Out-of-memory Repeat Tests"));

	test.Start(_L("Out-of-memory Repeat Tests"));

	DoOOMTestL(&TestOrphanedRscFileL, _L("TestOrphanedRscFileL"));

	DoOOMTestL(&TestInvalidSIDPluginL, _L("TestInvalidSIDPluginL"));

	DoOOMTestL(&TestOrphanedRscFileFallBackL, _L("TestOrphanedRscFileFallBackL"));

	DoOOMTestL(&TestPluginsDirectoryRemovingL, _L("TestPluginsDirectoryRemovingL"));

	test.End();

	__UHEAP_MARKEND;

	}

//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("Dual-Mode Discovery Tests"));

	TheTrapCleanup = CTrapCleanup::New();

	TInt err = TheFs.Connect();

	test(err == KErrNone);

	TRAP(err, SetupL());

	test(err == KErrNone);

	// Perform tests.

	TRAP(err,DoTestsL());

	test(err==KErrNone);

	delete TheActiveScheduler;

	TheFs.Close();

	delete TheTrapCleanup;

	test.End();

	test.Close();

	__UHEAP_MARKEND;

	return (KErrNone);

	}