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

 //

 #include <e32test.h>

 #include <f32file.h>

 #include <ecom/ecom.h>

 #include <startup.hrh>

 #include "EComSessionAux.h"

 #include "EcomTestUtils.h"

 #include "EcomTestIniFileUtils.h"

 #include "EcomTestCompTestabilityUtils.h"

 static RFs TheFs;

 static RTest TheTest(_L("T_EcomSsaDisabled"));

 _LIT(KEComExampleDllOnZ,	"Z:\\RAMOnly\\EComExample3.dll");

 _LIT(KEComExampleDllOnC,	"C:\\sys\\bin\\EComExample3.dll");

 _LIT(KEComPluginRscOnZ,		"Z:\\RAMOnly\\EComExample3.rsc");

 _LIT(KEComPluginRscOnC,		"C:\\resource\\plugins\\EComExample3.rsc");

 #ifdef __ECOM_SERVER_TESTABILITY__

 _LIT8(KImplementationDataOnZ,	"RomOnly");

 _LIT8(KImplementationDataOnC,	"RamOnly");

 const TInt KOneSecond = 1000000;

 #endif

 //

 //

 //Test macroes and functions

 //

 //

 #ifdef __ECOM_SERVER_TESTABILITY__

 static void Check(TInt aValue, TInt aLine)

 	{

 	if(!aValue)

 		{

 		TheTest(EFalse, aLine);

 		}

 	}

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

 #endif

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

 	{

 	if(aValue != aExpected)

 		{

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

 		TheTest(EFalse, aLine);

 		}

 	}

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

 //

 //

 //Helper functions

 //

 //

 /**

 * Add plugins to C: drive so they can be discovered during NonStatic discovery

 * state.

 */

 static void SetupFiles()

 	{

 	TRAPD(err, EComTestUtils::FileManCopyFileL(KEComExampleDllOnZ, KEComExampleDllOnC));

 	TEST2(err, KErrNone);

 	TRAP(err, EComTestUtils::FileManCopyFileL(KEComPluginRscOnZ, KEComPluginRscOnC));

 	TEST2(err, KErrNone);

 	}

 /**

 * Remove the plugins from C: drive so we can leave a clean environment for

 * the next test.

 */

 static void CleanupFiles()

 	{

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

 	TEST2(err, KErrNone);

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

 	TEST2(err, KErrNone);

 	}

 static void KillEComServerL()

 	{

 	//Need to ensure that the EComServer process is killed before even starting this test by using

    	//the EComTestUtils library

    	_LIT(KEComServerProcessName,"ecomserver");

    	TRAPD(error, EComTestUtils::KillProcessL(KEComServerProcessName));

    	error=error;

 	}

 /**

 * Test if the requested plugin is discovered

 *@param			aInterfaceUid A UID specifying the required interface.

 *@param			aResolutionParameters A descriptor specifying any additional

 *				implementation characteristics to be fulfilled.

 *@return		return TRUE if plugin exists

 */

 TBool TestForPlugin(TUid aInterfaceUid,

 					const TDesC8& aDataType)

 	{

 	TBool result = EFalse;

 	RImplInfoPtrArray aImplInfoArray;

 	TEComResolverParams resolverParams;

 	resolverParams.SetDataType(aDataType);

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

 	REComSession::ListImplementationsL(

 			aInterfaceUid,

 			resolverParams,

 			aImplInfoArray);

 	if(aImplInfoArray.Count() > 0)

 		{

 		result = ETrue;

 		}

 	aImplInfoArray.ResetAndDestroy();

 	return result;

 	}

 //

 //

 //Test functions

 //

 //

 #ifdef __ECOM_SERVER_TESTABILITY__

 /**

 @SYMTestCaseID		SYSLIB-ECOM-CIT-0187

 @SYMTestCaseDesc 	The SSA is disabled, the ECOM will do a full discovery with the

 simulated Domain Manager.

 @SYMTestPriority 	High

 @SYMTestActions  	Check the plugins and the state of ECOM using client API

 GetCurrentStartupStateL and ListImplementationsL.

 @SYMTestExpectedResults The test must not fail.

 @SYMPREQ PREQ967

 */

 LOCAL_C void TestEcomSsaDisabledL()

 	{

 	// Set up for heap leak checking

 	__UHEAP_MARK;

 	// and leaking thread handles

 	TInt startProcessHandleCount;

 	TInt startThreadHandleCount;

 	TInt endProcessHandleCount;

 	TInt endThreadHandleCount;

 	TInt state = EStartupStateUndefined;

 	// Test Starts...

 	RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

 	TUid ifUid = {0x10009DC0};

 	DisableSsa(TheTest, TheFs);

 	//Open the ecom session which in turn should start the ecom server.

 	//Next, wait to make sure that all the plugins are discovered.

 	//Finally, get rid of the ecom session.

 	REComSession& ecomSession = REComSession::OpenL();

 	CleanupClosePushL(ecomSession);

 	User::After(KOneSecond*10); //delay for 10 sec to ensure all plugins are discovered

 	CleanupStack::PopAndDestroy(&ecomSession);

 	//check that current state is EStartupStateUndefined

 	TRAPD(err, state = GetCurrentStartupStateL());

 	TEST2(err, KErrNone);

 	TEST2(state, EStartupStateNonCritical);

 	TEST2(ETrue, TestForPlugin(ifUid, KImplementationDataOnZ()));

 	TEST2(ETrue, TestForPlugin(ifUid, KImplementationDataOnC()));

 	REComSession::FinalClose();

 	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

 	TEST(startProcessHandleCount == endProcessHandleCount);

 	TEST(startThreadHandleCount  == endThreadHandleCount);

 	// Test Ends...

 	__UHEAP_MARKEND;

 	}

 #endif //__ECOM_SERVER_TESTABILITY__

 #ifdef __ECOM_SERVER_TESTABILITY__

 // Type definition for pointer to member function.

 // Used in calling t_ServerStartupMgr test functions.

 typedef void (*ClassFuncPtrL) (void);

 /**

 Wrapper function to call all test functions

 @param		testFunc pointer to test function

 @param		aTestDesc test function name

 */

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

 	{

 	TheTest.Next(aTestDesc);

 	__UHEAP_MARK;

   	// find out the number of open handles

 	TInt startProcessHandleCount;

 	TInt startThreadHandleCount;

 	RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

 	testFuncL();

 	// check that no handles have leaked

 	TInt endProcessHandleCount;

 	TInt endThreadHandleCount;

 	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

 	TEST(startProcessHandleCount == endProcessHandleCount);

 	TEST(startThreadHandleCount  == endThreadHandleCount);

 	__UHEAP_MARKEND;

 	}

 #endif //__ECOM_SERVER_TESTABILITY__

 LOCAL_C void DoTestsL()

 	{

 #ifdef __ECOM_SERVER_TESTABILITY__

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

 #endif //__ECOM_SERVER_TESTABILITY__

 	//We are not going to run OOM tests for several reasons:

 	//1- These tests are already done as part of the CEcomServer and

 	//CServerStartupMgr OOM tests

 	//2- EcomServer is running on another process

 	//3- We need to kill the EcomServer and start it again.

 	//For similar reasons to why we do not run OOM tests we should also

 	//not test Ecom startup behaviour in this component test executable.

 	//We will need to implement a new test executable for each test.

 	}

 GLDEF_C TInt E32Main()

 	{

 	__UHEAP_MARK;

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

 	TheTest.Title();

 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-ECOM-CIT-0187 Ecom Ssa Tests "));

 	TEST2(TheFs.Connect(), KErrNone);

 	// get clean-up stack

 	CTrapCleanup* cleanup = CTrapCleanup::New();

 	TRAPD(err, ::KillEComServerL());

 	TEST2(err, KErrNone);

 	DisableEcomTestBehaviour(TheTest, TheFs);

 	SetupFiles(); //Add plugins to C: drive

 	TRAP(err,DoTestsL());

 	TEST2(err, KErrNone);

 	CleanupFiles(); //Cleanup after test. Remove the plugins from C: drive

 	ResetSsa(TheTest, TheFs);

 	//Make sure that following tests start a fresh version of EComServer

 	TRAP(err, ::KillEComServerL());

 	TheTest.End();

 	TheTest.Close();

 	//delete scheduler;

 	delete cleanup;

 	TheFs.Close();

 	__UHEAP_MARKEND;

 	User::Heap().Check();

 	return KErrNone;

 	}