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