diff -r 000000000000 -r bde4ae8d615e os/ossrv/lowlevellibsandfws/pluginfw/Framework/EcomSsaDisabledTest/t_EcomSsaDisabled.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/lowlevellibsandfws/pluginfw/Framework/EcomSsaDisabledTest/t_EcomSsaDisabled.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,300 @@ +// 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 +#include +#include +#include +#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; + } + +