/*

* 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 FILES

#include <e32hal.h>	//User::HAL

#include <e32property.h> //RProperty

#include "t_oomharness.h"

#include "CDummyApplicationHandle.h"

#include "../../t_oomdummyapp/inc/t_oomdummyappmsgs.h"

#include "t_oomdummyplugin_properties.h"

#include <hal.h>

// EXTERNAL DATA STRUCTURES

// None

// EXTERNAL FUNCTION PROTOTYPES  

// None

// CONSTANTS

// None

// MACROS

// None

// LOCAL CONSTANTS AND MACROS

const TInt KOomJustUnderLowMemoryThreshold = 4000;

const TInt KOomSignificantlyUnderLowMemoryThreshold = 2024;

const TInt KOomBetweenLowAndGoodThresholds = 4300;

const TInt KOomJustAboveGoodMemoryThreshold = 5100;

const TInt KOomTestFirstIdlePeriod = 40000000; // 40 seconds

// MODULE DATA STRUCTURES

// None

// LOCAL FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

// None

// ==================== LOCAL FUNCTIONS =======================================

/*

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

    DESCRIPTION

    This module contains the implementation of COomTestHarness class 

    member functions that does the actual tests.

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

*/

// ============================ MEMBER FUNCTIONS ===============================

/*

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

    Class: COomTestHarness

    Method: Case

    Description: 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.

    Parameters:    const TInt aCaseNumber :in:      Test case number

    Return Values: const TCaseInfo Struct containing case name & function

    Errors/Exceptions: None

    Status: Proposal

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

*/ 

const TCaseInfo COomTestHarness::Case ( 

    const TInt aCaseNumber ) const 

     {

    /*

    * 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 

    *    OOMHard.cpp file and to OOMHard.h 

    *    header file.

    *

    * 2) Add entry to following KCases array either by using:

    *

    * 2.1: 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.

    *

    * Or

    *

    * 2.2: OOM_FUNCENTRY or OOM_ENTRY macro. Note that these macros are used

    * only with OOM (Out-Of-Memory) testing!

    *

    * OOM_ENTRY macro takes five parameters: test case name, test case 

    * function name, TBool which specifies is method supposed to be run using

    * OOM conditions, TInt value for first heap memory allocation failure and 

    * TInt value for last heap memory allocation failure.

    * 

    * OOM_FUNCENTRY macro takes test case function name as a parameter and uses

    * that as a test case name, TBool which specifies is method supposed to be

    * run using OOM conditions, TInt value for first heap memory allocation 

    * failure and TInt value for last heap memory allocation failure. 

    */ 

    static TCaseInfoInternal const KCases[] =

        {

        // To add new test cases, add new items to this array

        // NOTE: When compiled to GCCE, there must be Classname::

        // declaration in front of the method name, e.g. 

        // COomTestHarness::PrintTest. Otherwise the compiler

        // gives errors.

        ENTRY( "App Close Test 1", COomTestHarness::AppCloseTest1L ),

        ENTRY( "App Close Idle Time", COomTestHarness::AppCloseIdleTimeTest1L ),

        ENTRY( "App Close Equal Priorities", COomTestHarness::AppCloseEqualPrioritiesL ),        

        ENTRY( "Plugin Test 1", COomTestHarness::PluginTest1L ),

        ENTRY( "Plugin Test 2", COomTestHarness::PluginTest2L ),

        ENTRY( "App Plugin Test 1", COomTestHarness::AppPluginTest1L ),

        ENTRY( "App Plugin Idle Time Test 1", COomTestHarness::AppPluginIdleTimeTest1L ),

        ENTRY( "Optional Allocation Test 1", COomTestHarness::OptionalAllocationTest1L ),

        ENTRY( "Optional Allocation Test 2", COomTestHarness::OptionalAllocationTest2L ),

        ENTRY( "Optional Allocation Test 3", COomTestHarness::OptionalAllocationTest3L ),

        ENTRY( "Plugin V2 Test 1", COomTestHarness::PluginV2Test1L ),

        ENTRY( "Force Priority Check Test 1", COomTestHarness::ForcePriorityCheck1L ),

		ENTRY( "Plugin Sync Mode Test 1", COomTestHarness::PluginSyncModeTest1L ),

		ENTRY( "Never Close Test 1", COomTestHarness::NeverCloseTest1L ),

		ENTRY( "Optional Allocation Async Test 1", COomTestHarness::OptionalAllocationAsyncTest1L ),

		ENTRY( "Optional Allocation Async Test 2", COomTestHarness::OptionalAllocationAsyncTest2L ),

		ENTRY( "Optional Allocation Async Test 3", COomTestHarness::OptionalAllocationAsyncTest3L ),

#ifdef CLIENT_REQUEST_QUEUE

		ENTRY( "App Close Two Client Sessions", COomTestHarness::AppCloseTwoSessionsL ),

#endif		

        ENTRY( "Call If Target App Not Running Test 1", COomTestHarness::CallIfTargetAppNotRunningTest1L ),		

#ifdef __WINS__

        ENTRY( "App Close Specific Threshold Test 1", COomTestHarness::AppCloseSpecificThresholdTest1L ),     

#endif

        ENTRY( "Plugin Test Insufficient Memory Freed", COomTestHarness::PluginTestInsufficientMemoryFreedL ),

        ENTRY( "Plugin Test Insufficient Memory Freed 2", COomTestHarness::PluginTestInsufficientMemoryFreed2L ),

        };

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

        null.iIsOOMTest = EFalse;

        null.iFirstMemoryAllocation = 0;

        null.iLastMemoryAllocation = 0;

        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;

    }

TInt COomTestHarness::AppCloseTest1L(TTestResult& aResult)

	{

	ResetL();

	// The lowest priority app should be in the foregound

	// ... with the next lowest behind it

	// ... followed by the highest priority application at the back

	StartApplicationL(KOomTestAppUid, 5 * 1024); // P9 app

	StartApplicationL(KOomTestApp2Uid, 5 * 1024); // P8 app, configure it to eat 5MB

	StartApplicationL(KOomTestApp3Uid, 0); // P7 app

	BringAppToForeground(KOomTestApp3Uid);

	//start watchers

	TInt memTestState = ETestInit;

	TInt err = KErrNone;

	StartMemoryMonitorStatusWatcher(memTestState);

    // Go significantly under the low memory threshold

    EatMemoryL(KOomSignificantlyUnderLowMemoryThreshold);

    //start timer, start scheduler & stop watchers when done

    StartTimerAndRunWatcher(memTestState);

    if (err == KErrNone && memTestState == ETestAbove)

        {

        err = AppIsRunning(KOomTestApp2Uid, EFalse);

        if (err != KErrNone)

            {

            _LIT( KResult ,"P8 App KOomTestApp2Uid incorrectly running");

            aResult.iResultDes.Copy( KResult );

            aResult.iResult = KErrGeneral;

           // Case was executed but failed

            }

        if (err == KErrNone)

            {	

            err = AppIsRunning(KOomTestApp3Uid, ETrue);	

            if (err != KErrNone)

                {

                // The P7 app should still be running because it was in the foreground

                _LIT( KResult ,"(P7 App KOomTestApp3Uid not running");

                aResult.iResultDes.Copy( KResult );

                aResult.iResult = KErrGeneral;

                // Case was executed but failed

                }

            }

        if (err == KErrNone)

            {	

            err = AppIsRunning(KOomTestAppUid, ETrue);	

            if (err != KErrNone)

                {

                // The P9 app should still be running because the P8 application freed enough memory

                _LIT( KResult ,"P9 App KOomTestAppUid not running");

                aResult.iResultDes.Copy( KResult );

                aResult.iResult = KErrGeneral;

                // Case was executed but failed

                }

            }

        if (err == KErrNone)

            {

            _LIT( KDescription , "Test case passed");

            aResult.SetResult( KErrNone, KDescription );

            }

        }

    else

        {

        _LIT( KResult ,"Watchers failed to start or Application Timeout or Memory Still Below Treshhold ");

        aResult.iResultDes.Copy( KResult );

        aResult.iResult = KErrGeneral;

        // case was not executed or case was executed but never finished or failed 

        }

	ResetL();    

    return KErrNone;	

	}

// Tests the idle time rule mechanism for app closure

// Start three applications

// The lowest priority app should be in the foregound

// ... with the next lowest behind it

// ... followed by the highest priority application at the back

// After an idle period the highest priority app is configured to become the lowest priority

// The middle and highest application should be configured to eat 5MB of memory

// A low memory event is triggered and the middle application only should be closed

// Note that this test should be the same as AppCloseTest1L, with the exception of the idle period which causes different apps to be closed

TInt COomTestHarness::AppCloseIdleTimeTest1L(TTestResult& aResult)

	{

	ResetL();

	// The lowest priority app should be in the foregound

	// ... with the next lowest behind it

	// ... followed by the highest priority application at the back

	StartApplicationL(KOomTestAppUid, 5 * 1024); // P9 app (which becomes a P2 app after the idle time)

	StartApplicationL(KOomTestApp2Uid, 5 * 1024); // P8 app, configure it to eat 5MB

	StartApplicationL(KOomTestApp3Uid, 0); // P7 app

	BringAppToForeground(KOomTestApp3Uid);

	// Wait for the first set of idle time rules to apply

	User::After(KOomTestFirstIdlePeriod);

	//start watchers

	TInt memTestState = ETestInit;

    TInt err = KErrNone;

    StartMemoryMonitorStatusWatcher(memTestState);

    // Go significantly under the low memory threshold

    EatMemoryL(KOomSignificantlyUnderLowMemoryThreshold);

    //start timer, start scheduler & stop watchers when done

    StartTimerAndRunWatcher(memTestState);        

    if (err == KErrNone && memTestState == ETestAbove)

        {

	    err = AppIsRunning(KOomTestAppUid, EFalse);		

	    if (err != KErrNone)

	        {

	        // The P9 app should have become a P2 app after the idle period, therefore it should have been the first candidate for closure

	        _LIT( KResult ,"P9->P2 App KOomTestAppUid running");

	        aResult.iResultDes.Copy( KResult );

	        aResult.iResult = KErrGeneral;

	        // Case was executed but failed

	        }	

	    if (err == KErrNone)

	        {	

	        err = AppIsRunning(KOomTestApp2Uid, ETrue);

	        if (err != KErrNone)

	            {

	            // The P8 application should still be running because the P9 app (that has become a P2 app) has freed the required memory

	            _LIT( KResult ,"P8 App KOomTestApp2Uid not running");

	            aResult.iResultDes.Copy( KResult );

	            aResult.iResult = KErrGeneral;

	            // Case was executed but failed

	            }		

	        }

	    if (err == KErrNone)

	        {	

	        err = AppIsRunning(KOomTestApp3Uid, ETrue);	

	        if (err != KErrNone)

	            {

	            // The P7 app should still be running because it was in the foreground

	            _LIT( KResult ,"P7 App KOomTestApp3Uid not running");

	            aResult.iResultDes.Copy( KResult );

	            aResult.iResult = KErrGeneral;

	            // Case was executed but failed

	            }	

	        }

	    if (err == KErrNone)

	        {

	        _LIT( KDescription , "Test case passed");

	        aResult.SetResult( KErrNone, KDescription );

	        }

        }

    else

        {

        _LIT( KResult ,"Watchers failed to start or Application Timeout or Memory Still Below Treshhold ");

        aResult.iResultDes.Copy( KResult );

        aResult.iResult = KErrGeneral;

        // case was not executed or case was executed but never finished or failed 

        }

	ResetL();    

    return KErrNone;	

	}

TInt COomTestHarness::AppCloseEqualPrioritiesL(TTestResult& aResult)

	{

	ResetL();

	StartApplicationL(KOomTestApp4Uid, 3 * 1024); // P7 app1, configure it to eat 5MB

	Settle();	

	StartApplicationL(KOomTestApp3Uid, 3 * 1024); // P7 app2, configure it to eat 5MB

	Settle();

	StartApplicationL(KOomTestApp5Uid, 3 * 1024); // P7 app3, configure it to eat 5MB

	Settle();	

	StartApplicationL(KOomTestAppUid, 0); //P9 app

	Settle();

    //start watchers

    TInt memTestState = ETestInit;

    TInt err = KErrNone;

    StartMemoryMonitorStatusWatcher(memTestState);

    // Go significantly under the low memory threshold

    EatMemoryL(KOomSignificantlyUnderLowMemoryThreshold);

    //start timer, start scheduler & stop watchers when done

    StartTimerAndRunWatcher(memTestState);

    if (err == KErrNone && memTestState == ETestAbove)

        {

        err = AppIsRunning(KOomTestApp4Uid, EFalse);	

        if (err != KErrNone)

            {

            // The P7 app furthest to the back in the z order should be closed.

            // This should release sufficient memory.

            _LIT( KResult ,"P7 App KOomTestApp4Uid incorrectly running");

            aResult.iResultDes.Copy( KResult );

            aResult.iResult = KErrGeneral;

           // Case was executed but failed

            }

        // the other 3 apps should all still be running

        if (err == KErrNone)

            {	

            err = AppIsRunning(KOomTestApp3Uid, ETrue);	

            if (err != KErrNone)

                {

                _LIT( KResult ,"App KOomTestApp3Uid not running");

                aResult.iResultDes.Copy( KResult );

                aResult.iResult = KErrGeneral;

                // Case was executed but failed

                }

            }

        if (err == KErrNone)

            {	

            err = AppIsRunning(KOomTestApp5Uid, ETrue);	

            if (err != KErrNone)

                {

                _LIT( KResult ,"App KOomTestApp5Uid not running");

                aResult.iResultDes.Copy( KResult );

                aResult.iResult = KErrGeneral;

                // Case was executed but failed

                }

            }

        if (err == KErrNone)

            {	

            err = AppIsRunning(KOomTestAppUid, ETrue);	

            if (err != KErrNone)

                {

                // The P9 app should still be running because the P8 application freed enough memory

                _LIT( KResult ,"P9 App KOomTestAppUid not running");

                aResult.iResultDes.Copy( KResult );

                aResult.iResult = KErrGeneral;

                // Case was executed but failed

                }

            }

        if (err == KErrNone)

            {

            _LIT( KDescription , "Test case passed");

            aResult.SetResult( KErrNone, KDescription );

            }

        }

    else

        {

        _LIT( KResult ,"Watchers failed to start or Application Timeout or Memory Still Below Treshhold ");

        aResult.iResultDes.Copy( KResult );

        aResult.iResult = KErrGeneral;

        // case was not executed or case was executed but never finished or failed 

        }

	ResetL();    

    return KErrNone;	

	}

TInt COomTestHarness::PluginTest1L(TTestResult& aResult)

	{

	ResetL();

	// Configure the plugins to eat 0.6MB each:

	for (TInt pluginIndex = KUidOOMDummyPluginFirstImplementation; pluginIndex <= KUidOOMDummyPluginLastImplementation - 2; pluginIndex++)

		{

		User::LeaveIfError(iAllocServer.Configure(TUid::Uid(pluginIndex), 0, 0x96000, 0x96000));

		}

	//start application so that plugin 0x10286A3A which does the check can be called

	StartApplicationL(KOomTestApp2Uid, 0);

    //start watchers

    TInt memTestState = ETestInit;

    TInt err = KErrNone;

    StartMemoryMonitorStatusWatcher(memTestState);

    // Go just under the low memory threshold

    EatMemoryL(KOomJustUnderLowMemoryThreshold);

    //start timer, start scheduler & stop watchers when done

    StartTimerAndRunWatcher(memTestState);

    if (err == KErrNone && memTestState == ETestAbove)

        {	

        // The first two app plugins should have been run, releasing 

        // the required memory. The second app plugin to be run - 10286A3A - has a check,

        // so no other plugins should have run.

        err = PluginFreeRamCalledL(0x10286A3B, ETrue);	

        if (err != KErrNone)

            {

            _LIT( KResult ,"Plugin 0x10286A3B FreeRam not called");

            aResult.iResultDes.Copy( KResult );

            aResult.iResult = KErrGeneral;

            // Case was executed but failed

            }

        if (err == KErrNone)

            {	

            err = PluginFreeRamCalledL(0x10286A3A, ETrue);

            if (err != KErrNone)

                {

                _LIT( KResult ,"Plugin 0x10286A3A FreeRam not called");

                aResult.iResultDes.Copy( KResult );

                aResult.iResult = KErrGeneral;

                // Case was executed but failed

                }

            }

        // These two plugins should not be called	

        if (err == KErrNone)