diff -r ccb4f6b3db21 -r 8cb079868133 sysstatemgmt/tsrc/public/basic/mt_rstartersession/MT_RStarterSession.cpp --- a/sysstatemgmt/tsrc/public/basic/mt_rstartersession/MT_RStarterSession.cpp Tue Aug 31 16:29:05 2010 +0300 +++ b/sysstatemgmt/tsrc/public/basic/mt_rstartersession/MT_RStarterSession.cpp Wed Sep 01 12:34:26 2010 +0100 @@ -11,7 +11,7 @@ * * Contributors: * -* Description: Unit test code for RStarterSession class +* Description: * */ @@ -20,30 +20,30 @@ #include "MT_RStarterSession.h" // EXTERNAL INCLUDES -#include -#include +#include +#include // INTERNAL INCLUDES #include #include -// --------------------------------------------------------- -// MT_RStarterSession::LibEntryL -// Returns: Poiter to MT_RStarterSession class -// --------------------------------------------------------- -EXPORT_C MT_RStarterSession* LibEntryL( CTestModuleIf& aTestModuleIf ) +// CONSTRUCTION +MT_RStarterSession* MT_RStarterSession::NewL() { - RDebug::Printf("MT_RStarterSession* LibEntryL"); - MT_RStarterSession* libEntry( MT_RStarterSession::NewL( aTestModuleIf ) ); - return libEntry; + MT_RStarterSession* self = MT_RStarterSession::NewLC(); + CleanupStack::Pop(); + + return self; } -// CONSTRUCTION -MT_RStarterSession* MT_RStarterSession::NewL(CTestModuleIf& aTestModuleIf) +MT_RStarterSession* MT_RStarterSession::NewLC() { - RDebug::Printf("MT_RStarterSession* NewL"); - MT_RStarterSession* self = new ( ELeave ) MT_RStarterSession( aTestModuleIf ); + MT_RStarterSession* self = new( ELeave ) MT_RStarterSession(); + CleanupStack::PushL( self ); + + self->ConstructL(); + return self; } @@ -54,163 +54,28 @@ } // Default constructor -MT_RStarterSession::MT_RStarterSession(CTestModuleIf& /*aTestModuleIf*/) +MT_RStarterSession::MT_RStarterSession() { } -// ----------------------------------------------------------------------------- -// MT_SysLangUtil::Case -// Returns a test case by number. -// -// This function contains an array of all available test cases -// i.e pair of case name and test function. If case specified by parameter -// aCaseNumber is found from array, then that item is returned. -// -// The reason for this rather complicated function is to specify all the -// test cases only in one place. It is not necessary to understand how -// function pointers to class member functions works when adding new test -// cases. See function body for instructions how to add new test case. -// ----------------------------------------------------------------------------- -// -const TCaseInfo MT_RStarterSession::Case( const TInt aCaseNumber ) const +// Second phase construct +void MT_RStarterSession::ConstructL() { - - /** - * To add new test cases, implement new test case function and add new - * line to KCases array specify the name of the case and the function - * doing the test case - * In practice, do following - * 1) Make copy of existing test case function and change its name - * and functionality. Note that the function must be added to - * CenRepNotifyHandlerTest.cpp file and to CenRepNotifyHandlerTest.h - * header file. - * 2) Add entry to following KCases array either by using FUNCENTRY or - * ENTRY macro. - * ENTRY macro takes two parameters: test case name and test case - * function name. - * FUNCENTRY macro takes only test case function name as a parameter and uses - * that as a test case name and test case function name. - */ - RDebug::Printf("MT_RStarterSession* case"); - static TCaseInfoInternal const KCases[] = - { - // To add new test cases, add new items to this array - ENTRY( "1 [RStarterSession] Test ConectL", &MT_RStarterSession::T_RStarterSession_Connect ), - ENTRY( "2 [RStarterSession] Test SetState to Normal", &MT_RStarterSession::T_RStarterSession_SetStateToNormal), - ENTRY( "3 [RStarterSession] Test SetStateti Alarm", &MT_RStarterSession::T_RStarterSession_SetStateToAlarm), - ENTRY( "4 [RStarterSession] Test SetState to Charging", &MT_RStarterSession::T_RStarterSession_SetStateToCharging), - ENTRY( "5 [RStarterSession] Test SetState to OffLine", &MT_RStarterSession::T_RStarterSession_SetStateToOffLine), - ENTRY( "6 [RStarterSession] Test SetState to BTSap", &MT_RStarterSession::T_RStarterSession_SetStateToBTSap), - ENTRY( "7 [RStarterSession] Test ResetNetwork", &MT_RStarterSession::T_RStarterSession_ResetNetwork), - ENTRY( "8 [RStarterSession] Test IsRTCTimeValid", &MT_RStarterSession::T_RStarterSession_IsRTCTimeValid), - ENTRY( "9 [RStarterSession] Test ActivateRfForEmergencyCall", &MT_RStarterSession::T_RStarterSession_ActivateRfForEmergencyCall ), - ENTRY( "10 [RStarterSession] Test DeactivateRfAfterEmergencyCall", &MT_RStarterSession::T_RStarterSession_DeactivateRfAfterEmergencyCall), - ENTRY( "11 [RStarterSession] Test EndSplashScreen", &MT_RStarterSession::T_RStarterSession_EndSplashScreen), - ENTRY( "12 [RStarterSession] Test Reset", &MT_RStarterSession::T_RStarterSession_Reset), - ENTRY( "13 [RStarterSession] Test Shutdown", &MT_RStarterSession:: T_RStarterSession_Shutdown) - }; - - // Verify that case number is valid - if( (TUint) aCaseNumber >= sizeof( KCases ) / sizeof( TCaseInfoInternal ) ) - { - // Invalid case, construct empty object - TCaseInfo null( (const TText*) L"" ); - null.iMethod = NULL; - return null; - } - - // Construct TCaseInfo object and return it - TCaseInfo tmp ( KCases[aCaseNumber].iCaseName ); - tmp.iMethod = KCases[aCaseNumber].iMethod; - tmp.iIsOOMTest = KCases[ aCaseNumber ].iIsOOMTest; - tmp.iFirstMemoryAllocation = KCases[ aCaseNumber ].iFirstMemoryAllocation; - tmp.iLastMemoryAllocation = KCases[ aCaseNumber ].iLastMemoryAllocation; - - return tmp; - } - -// ----------------------------------------------------------------------------- -// MT_SysLangUtil::GetTestCasesL -// GetTestCases is used to inquire test cases from the Test Module. Test -// cases are stored to array of test cases. The Test Framework will be -// the owner of the data in the RPointerArray after GetTestCases return -// and it does the memory deallocation. -// ----------------------------------------------------------------------------- -// -TInt MT_RStarterSession::GetTestCasesL( const TFileName& /*aConfig*/, - RPointerArray& aTestCases ) - { - RDebug::Printf("MT_RStarterSession* gettestcase"); - // Loop through all test cases and create new - // TTestCaseInfo items and append items to aTestCase array - for( TInt i = 0; Case(i).iMethod != NULL; i++ ) - { - - // Allocate new TTestCaseInfo from heap for a testcase definition. - TTestCaseInfo* newCase = new( ELeave ) TTestCaseInfo; - - // PushL TTestCaseInfo to CleanupStack. - CleanupStack::PushL( newCase ); - - // Set number for the testcase. - // When the testcase is run, this comes as a parameter to RunTestCaseL. - newCase->iCaseNumber = i; - - // Set title for the test case. This is shown in UI to user. - newCase->iTitle.Copy( Case(i).iCaseName ); - - // Append TTestCaseInfo to the testcase array. After appended - // successfully the TTestCaseInfo object is owned (and freed) - // by the TestServer. - User::LeaveIfError(aTestCases.Append ( newCase ) ); - - // Pop TTestCaseInfo from the CleanupStack. - CleanupStack::Pop( newCase ); - } - return KErrNone; - } - -// ----------------------------------------------------------------------------- -// MT_SysLangUtil::RunTestCaseL -// RunTestCaseL is used to run an individual test case specified -// by aTestCase. Test cases that can be run may be requested from -// Test Module by GetTestCases method before calling RunTestCase. -// ----------------------------------------------------------------------------- -// -TInt MT_RStarterSession::RunTestCaseL( const TInt aCaseNumber, - const TFileName& /*aConfig*/, - TTestResult& aResult ) - { - - // Return value - TInt execStatus = KErrNone; - - // Get the pointer to test case function - TCaseInfo tmp = Case ( aCaseNumber ); - - // Check that case number was valid - if ( tmp.iMethod != NULL ) - { - // Valid case was found, call it via function pointer - iMethod = tmp.iMethod; - execStatus = ( this->*iMethod )( aResult ); - } - else - { - // Valid case was not found, return error. - execStatus = KErrNotFound; - } - - // Return case execution status (not the result of the case execution) - return execStatus; + // The ConstructL from the base class CEUnitTestSuiteClass must be called. + // It generates the test case table. + CEUnitTestSuiteClass::ConstructL(); } // METHODS + + +void MT_RStarterSession::SetupEmptyL( ) + { + } void MT_RStarterSession::SetupL( ) { - TInt err = iRStarterSession.Connect(); - RDebug::Print(_L("MT_RStarterSession* SetupL Connected to RStarterSession with % error"),err); + iRStarterSession.Connect(); } void MT_RStarterSession::Teardown( ) @@ -218,195 +83,155 @@ iRStarterSession.Close(); } -TInt MT_RStarterSession::T_RStarterSession_Connect( TTestResult& aResult ) +void MT_RStarterSession::TeardownEmpty( ) + { + } + +void MT_RStarterSession::T_RStarterSession_ConnectL( ) { RStarterSession session; TInt err = session.Connect(); - if ( err != KErrNone ) - { - _LIT( KDescription, "Incorrect return value in T_RStarterSession_Connect" ); - aResult.SetResult( err, KDescription ); - return err; - } + EUNIT_PRINT( _L("Connect() err = %d"), err ); + EUNIT_ASSERT_DESC( err == KErrNone, "Incorrect return value"); + session.Close(); - return err; + } + +void MT_RStarterSession::T_RStarterSession_SetStateL( ) + { + // Perhaps test also other values... + TInt err = iRStarterSession.SetState( RStarterSession::ENormal ); + EUNIT_PRINT( _L("SetState() err = %d"), err ); + EUNIT_ASSERT_DESC( err == KErrNone, "Incorrect return value"); + } + +void MT_RStarterSession::T_RStarterSession_ResetL( ) + { + // Perhaps test also other values... + iRStarterSession.Reset( (RStarterSession::TResetReason)-1 ); + } + +void MT_RStarterSession::T_RStarterSession_ShutdownL( ) + { + EUNIT_PRINT( _L("Calling Shutdown()") ); + iRStarterSession.Shutdown( ); + } + +void MT_RStarterSession::T_RStarterSession_ResetNetworkL( ) + { + TInt err = iRStarterSession.ResetNetwork( ); + EUNIT_PRINT( _L("ResetNetwork() err = %d"), err ); + + EUNIT_ASSERT_DESC( err == KErrNone, "Incorrect return value"); } -TInt MT_RStarterSession::T_RStarterSession_SetStateToNormal( TTestResult& aResult ) - { - SetupL(); - // State transition from Normal to normal - TInt err = iRStarterSession.SetState( RStarterSession::ENormal ); - - if ( (err != KErrArgument) && (err != KErrGeneral) && (err != KErrNone)) - { - _LIT( KDescription, "Incorrect return value in T_RStarterSession_SetStateToNormal " ); - aResult.SetResult( err, KDescription ); - return err; - } - Teardown(); - return KErrNone; - } - -TInt MT_RStarterSession::T_RStarterSession_SetStateToAlarm( TTestResult& aResult ) +void MT_RStarterSession::T_RStarterSession_IsRTCTimeValidL( ) { - SetupL(); - // State transition from normal to Alarm - TInt err = iRStarterSession.SetState( RStarterSession::EAlarm ); + TBool valid = iRStarterSession.IsRTCTimeValid(); + EUNIT_PRINT( _L("IsRTCTimeValid() returned = %d"), valid ); + } - if ( err != KErrNotSupported ) - { - _LIT( KDescription, "Incorrect return value T_RStarterSession_SetStateToAlarm" ); - aResult.SetResult( err, KDescription ); - return err; - } - Teardown(); - return KErrNone; +void MT_RStarterSession::T_RStarterSession_ActivateRfForEmergencyCallL( ) + { + TInt err = iRStarterSession.ActivateRfForEmergencyCall( ); + EUNIT_PRINT( _L("ActivateRfForEmergencyCall() err = %d"), err ); + // Do not check the return value since in some cases it is normal that + // KErrGeneral(-2) is returned + //EUNIT_ASSERT_DESC( err == KErrNone, "Incorrect return value" ); } - -TInt MT_RStarterSession::T_RStarterSession_SetStateToCharging( TTestResult& aResult ) - { - SetupL(); - // State transition from normal to ECharging - TInt err = iRStarterSession.SetState( RStarterSession::ECharging ); - if ( err != KErrNotSupported ) - { - _LIT( KDescription, "Incorrect return value in T_RStarterSession_SetStateEToCharging " ); - aResult.SetResult( err, KDescription ); - return err; - } - Teardown(); - return KErrNone; +void MT_RStarterSession::T_RStarterSession_DeactivateRfAfterEmergencyCallL( ) + { + TInt err = iRStarterSession.DeactivateRfAfterEmergencyCall( ); + EUNIT_PRINT( _L("DeactivateRfAfterEmergencyCall() err = %d"), err ); + EUNIT_ASSERT_DESC( err == KErrNone, "Incorrect return value" ); + + // Activate RF again + err = iRStarterSession.ActivateRfForEmergencyCall( ); + EUNIT_PRINT( _L("ActivateRfForEmergencyCall() err = %d"), err ); + // Do not check the return value since in some cases it is normal that + // KErrGeneral(-2) is returned + //EUNIT_ASSERT_DESC( err == KErrNone, "Incorrect return value" ); } - -TInt MT_RStarterSession::T_RStarterSession_SetStateToOffLine( TTestResult& aResult ) - { - SetupL(); - // State transition from normal to EOffline - TInt err = iRStarterSession.SetState( RStarterSession::EOffline ); - if ( err != KErrNone ) - { - _LIT( KDescription, "Incorrect return value in T_RStarterSession_SetStateTOOffLine " ); - aResult.SetResult( err, KDescription ); - return err; - } - Teardown(); - return err; - } - -TInt MT_RStarterSession::T_RStarterSession_SetStateToBTSap( TTestResult& aResult ) +void MT_RStarterSession::T_RStarterSession_EndSplashScreenL( ) { - SetupL(); - // State transition from ENormal to EBTSap - TInt err = iRStarterSession.SetState( RStarterSession::EBTSap ); - - if ( err != KErrNone ) - { - _LIT( KDescription, "Incorrect return value in T_RStarterSession_SetStateToBTSap " ); - aResult.SetResult( err, KDescription ); - return err; - } - Teardown(); - return err; + TInt err = iRStarterSession.EndSplashScreen( ); + EUNIT_PRINT( _L("EndSplashScreen() err = %d"), err ); + EUNIT_ASSERT_DESC( err == KErrNone, "Incorrect return value" ); } -TInt MT_RStarterSession::T_RStarterSession_Reset( TTestResult& aResult ) - { - SetupL(); - // Other values will be tested in BAT testing (Manual testing)... - iRStarterSession.Reset( (RStarterSession::TResetReason)-1 ); - // Make request and ignore return value - _LIT( KDescription, "T_RStarterSession_Reset - Calling Reset()" ); - aResult.SetResult( KErrNone, KDescription ); - Teardown(); - return KErrNone; - } +// TEST TABLE +EUNIT_BEGIN_TEST_TABLE( + MT_RStarterSession, + "Add test suite description here.", + "UNIT" ) + +EUNIT_TEST( + "Connect - test0", + "RStarterSession", + "Connect - test0", + "FUNCTIONALITY", + SetupEmptyL, T_RStarterSession_ConnectL, TeardownEmpty) -TInt MT_RStarterSession::T_RStarterSession_Shutdown(TTestResult& aResult ) - { - SetupL(); - iRStarterSession.Shutdown( ); - _LIT( KDescription, "T_RStarterSession_Shutdown - Calling Shutdown()" ); - aResult.SetResult( KErrNone, KDescription ); - Teardown(); - return KErrNone; - } +EUNIT_TEST( + "SetState - test1", + "RStarterSession", + "SetState - test1", + "FUNCTIONALITY", + SetupL, T_RStarterSession_SetStateL, Teardown) -TInt MT_RStarterSession::T_RStarterSession_ResetNetwork(TTestResult& aResult ) - { - SetupL(); - TInt err = iRStarterSession.ResetNetwork( ); - if ( err != KErrNone ) - { - _LIT( KDescription, "T_RStarterSession_ResetNetwork - Incorrect return value in " ); - aResult.SetResult( err, KDescription ); - return err; - } - Teardown(); - return err; - } +EUNIT_TEST( + "Reset - test2", + "RStarterSession", + "Reset - test2", + "FUNCTIONALITY", + SetupL, T_RStarterSession_ResetL, Teardown) + +EUNIT_TEST( + "ResetNetwork - test4", + "RStarterSession", + "ResetNetwork - test4", + "FUNCTIONALITY", + SetupL, T_RStarterSession_ResetNetworkL, Teardown) -TInt MT_RStarterSession::T_RStarterSession_IsRTCTimeValid(TTestResult& aResult ) - { - SetupL(); - TBool valid = iRStarterSession.IsRTCTimeValid(); - if ( !valid ) - { - _LIT( KDescription, "Incorrect return value in T_RStarterSession_IsRTCTimeValid " ); - aResult.SetResult( valid, KDescription ); - return valid; - } - Teardown(); - return KErrNone; - } +EUNIT_TEST( + "IsRTCTimeValid - test5", + "RStarterSession", + "IsRTCTimeValid - test5", + "FUNCTIONALITY", + SetupL, T_RStarterSession_IsRTCTimeValidL, Teardown) -TInt MT_RStarterSession::T_RStarterSession_ActivateRfForEmergencyCall(TTestResult& aResult ) - { - SetupL(); - TInt err = iRStarterSession.ActivateRfForEmergencyCall( ); - - if (( err != KErrNone) && (err != KErrGeneral)) - { - _LIT( KDescription, "Incorrect return value in T_RStarterSession_ActivateRfForEmergencyCall" ); - aResult.SetResult( err, KDescription ); - return err; - } - Teardown(); - return err; - } +EUNIT_TEST( + "ActivateRfForEmergencyCall - test6", + "RStarterSession", + "ActivateRfForEmergencyCall - test6", + "FUNCTIONALITY", + SetupL, T_RStarterSession_ActivateRfForEmergencyCallL, Teardown) -TInt MT_RStarterSession::T_RStarterSession_DeactivateRfAfterEmergencyCall( TTestResult& aResult ) - { - SetupL(); - TInt err = iRStarterSession.DeactivateRfAfterEmergencyCall( ); +EUNIT_TEST( + "DeactivateRfAfterEmergencyCall - test7", + "RStarterSession", + "DeactivateRfAfterEmergencyCall - test7", + "FUNCTIONALITY", + SetupL, T_RStarterSession_DeactivateRfAfterEmergencyCallL, Teardown) - if (( err != KErrNone) && (err != KErrGeneral)) - { - _LIT( KDescription, "Incorrect return value in T_RStarterSession_DeactivateRfAfterEmergencyCall" ); - aResult.SetResult( err, KDescription ); - return err; - } - // Activate RF again - err = iRStarterSession.ActivateRfForEmergencyCall( ); - Teardown(); - return err; - } +EUNIT_TEST( + "EndSplashScreen - test8", + "RStarterSession", + "EndSplashScreen - test8", + "FUNCTIONALITY", + SetupL, T_RStarterSession_EndSplashScreenL, Teardown) -TInt MT_RStarterSession::T_RStarterSession_EndSplashScreen( TTestResult& aResult ) - { - SetupL(); - TInt err = iRStarterSession.EndSplashScreen( ); - if ( err != KErrNone ) - { - _LIT( KDescription, "Incorrect return value in T_RStarterSession_EndSplashScreen" ); - aResult.SetResult( err, KDescription ); - return err; - } - Teardown(); - return err; - } +/* +EUNIT_TEST( + "Shutdown - test3", + "RStarterSession", + "Shutdown - test3", + "FUNCTIONALITY", + SetupL, T_RStarterSession_ShutdownL, Teardown)*/ + +EUNIT_END_TEST_TABLE -//END OF FILE +// END OF FILE