/*

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

*

*/

#ifndef T_OOMHARNESS_H

#define T_OOMHARNESS_H

// INCLUDES

#include "StifTestModule.h"

#include <StifLogger.h>

#include <e32hashtab.h>

#include <e32cmn.h>

#include "CDummyApplicationHandle.h"

#include "t_oomclient.h"

#include <oommonitorsession.h>

#include <e32property.h>

// CONSTANTS

const TInt KSettlingTime = 2000000;

const TInt KOomHarnessInitialEatenMemory= 1024; // Just eat 1K of memory initially, this can grow later

const TInt KOomHarnessMaxEatenMemory = 64 * 1024 * 1024;

const TInt KTimeout = 20000000; //20 secs

enum TTestStates

    {

    // EInit: Test initialisation phase

    ETestInit,

    // EPossiblePass: In the case of memorymonitor reporting EAboveTreshhold

    ETestAbove,

    // EFail: All other cases including timeout

    ETestBelow,

    ETestTimeout

    };

// MACROS

// None

// Logging path

_LIT( KT_OomHarnessLogPath, "\\logs\\testframework\\T_OomHarness\\" ); 

// Log file

_LIT( KT_OomHarnessLogFile, "T_OomHarness.txt" ); 

_LIT( KT_OomHarnessLogFileWithTitle, "T_OomHarness_[%S].txt" ); 

// Function pointer related internal definitions

// Rounding known bug in GCC

#define GETPTR &  

#define ENTRY(str,func) {_S(str), GETPTR func,0,0,0}

#define FUNCENTRY(func) {_S(#func), GETPTR func,0,0,0}

#define OOM_ENTRY(str,func,a,b,c) {_S(str), GETPTR func,a,b,c}

#define OOM_FUNCENTRY(func,a,b,c) {_S(#func), GETPTR func,a,b,c}

// FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

class COomTestHarness;

class CMemoryMonitorStatusWatcher;

class CMemoryMonitorTimeoutWatcher;

// DATA TYPES

// None

// A typedef for function that does the actual testing,

// function is a type 

// TInt COomTestHarness::<NameOfFunction> ( TTestResult& aResult )

typedef TInt (COomTestHarness::* TestFunction)(TTestResult&);    

// CLASS DECLARATION

/**

*  An internal structure containing a test case name and

*  the pointer to function doing the test

*

*  @lib ?library

*  @since ?Series60_version

*/

class TCaseInfoInternal

    {

    public:

        const TText* iCaseName;

        TestFunction iMethod;

        TBool           iIsOOMTest;

        TInt            iFirstMemoryAllocation;

        TInt            iLastMemoryAllocation;

    };

// CLASS DECLARATION

/**

*  A structure containing a test case name and

*  the pointer to function doing the test

*

*  @lib ?library

*  @since ?Series60_version

*/

class TCaseInfo

    {

    public:

        TPtrC iCaseName;    

        TestFunction iMethod;

        TBool           iIsOOMTest;

        TInt            iFirstMemoryAllocation;

        TInt            iLastMemoryAllocation;

    TCaseInfo( const TText* a ) : iCaseName( (TText*) a )

        {        

        };

    };

// CLASS DECLARATION

/**

*  This a T_OomHarness class.

*  ?other_description_lines

*

*  @lib ?library

*  @since ?Series60_version

*/

NONSHARABLE_CLASS(COomTestHarness) : public CTestModuleBase

    {

    public:  // Constructors and destructor

        /**

        * Two-phased constructor.

        */

        static COomTestHarness* NewL();

        /**

        * Destructor.

        */

        virtual ~COomTestHarness();

    public: // New functions

    // None

    public: // Functions from base classes

        /**

        * From CTestModuleBase InitL is used to initialize the 

        *       T_OomHarness. It is called once for every instance of 

        *       TestModule T_OomHarness after its creation.

        * @since ?Series60_version

        * @param aIniFile Initialization file for the test module (optional)

        * @param aFirstTime Flag is true when InitL is executed for first 

        *               created instance of T_OomHarness.

        * @return Symbian OS error code

        */

        TInt InitL( TFileName& aIniFile, TBool aFirstTime );

        /**

        * From CTestModuleBase GetTestCasesL is used to inquiry test cases 

        *   from T_OomHarness. 

        * @since ?Series60_version

        * @param aTestCaseFile Test case file (optional)

        * @param aTestCases  Array of TestCases returned to test framework

        * @return Symbian OS error code

        */

        TInt GetTestCasesL( const TFileName& aTestCaseFile, 

                            RPointerArray<TTestCaseInfo>& aTestCases );

        /**

        * From CTestModuleBase RunTestCaseL is used to run an individual 

        *   test case. 

        * @since ?Series60_version

        * @param aCaseNumber Test case number

        * @param aTestCaseFile Test case file (optional)

        * @param aResult Test case result returned to test framework (PASS/FAIL)

        * @return Symbian OS error code (test case execution error, which is 

        *           not reported in aResult parameter as test case failure).

        */   

        TInt RunTestCaseL( const TInt aCaseNumber, 

                           const TFileName& aTestCaseFile,

                           TTestResult& aResult );

        /**

        * From CTestModuleBase; OOMTestQueryL is used to specify is particular

        * test case going to be executed using OOM conditions

        * @param aTestCaseFile Test case file (optional)

        * @param aCaseNumber Test case number (optional)

        * @param aFailureType OOM failure type (optional)

        * @param aFirstMemFailure The first heap memory allocation failure value (optional)

        * @param aLastMemFailure The last heap memory allocation failure value (optional)

        * @return TBool

        */

        virtual TBool OOMTestQueryL( const TFileName& /* aTestCaseFile */, 

                                     const TInt /* aCaseNumber */, 

                                     TOOMFailureType& aFailureType,

                                     TInt& /* aFirstMemFailure */, 

                                     TInt& /* aLastMemFailure */ );

        /**

        * From CTestModuleBase; OOMTestInitializeL may be used to initialize OOM

        * test environment

        * @param aTestCaseFile Test case file (optional)

        * @param aCaseNumber Test case number (optional)

        * @return None

        */

        virtual void OOMTestInitializeL( const TFileName& /* aTestCaseFile */, 

                                    const TInt /* aCaseNumber */ ); 

        /**

        * From CTestModuleBase; OOMTestFinalizeL may be used to finalize OOM

        * test environment

        * @param aTestCaseFile Test case file (optional)

        * @param aCaseNumber Test case number (optional)

        * @return None

        */

        virtual void OOMTestFinalizeL( const TFileName& /* aTestCaseFile */, 

                                       const TInt /* aCaseNumber */ );

        /**

        * From CTestModuleBase; OOMHandleWarningL

        * @param aTestCaseFile Test case file (optional)

        * @param aCaseNumber Test case number (optional)

        * @param aFailNextValue FailNextValue for OOM test execution (optional)

        * @return None

        */

        virtual void OOMHandleWarningL( const TFileName& /* aTestCaseFile */,

                                        const TInt /* aCaseNumber */, 

                                        TInt& /* aFailNextValue */);

        void AllocateMemoryL(TInt aKBytes);

    protected:  // New functions    

    // None

    protected:  // Functions from base classes

    // None

    private:

        /**

        * C++ default constructor.

        */

        COomTestHarness();

        /**

        * By default Symbian 2nd phase constructor is private.

        */

        void ConstructL();

        // Prohibit copy constructor if not deriving from CBase.

        // ?classname( const ?classname& );

        // Prohibit assigment operator if not deriving from CBase.

        // ?classname& operator=( const ?classname& );

        /**

        * Function returning test case name and pointer to test case function.

        * @since ?Series60_version

        * @param aCaseNumber test case number

        * @return TCaseInfo 

        */

        const TCaseInfo Case ( const TInt aCaseNumber ) const;

        // Test setup functions...

        	// Close any dummy apps

        	// Free all memory being eaten by the server

        	// Update the call counts on the plugins (add them if they're not there already)

        	void ResetL();

        	void EatMemoryL(TInt aKBytesToLeaveFree);

        	// Set up the plugins and applications - this is the starting point for many test cases

        	// 5 applications are started with approx 1 MB used for each

        	// 1MB (approx) of memory is reserved for each one of the plugins

        	void CommonSetUpL();

        	void StartApplicationL(TInt32 aUid, TInt aInitialAllocationInKBs);

        // Results checking functions...

        	// Returns KErrNone if we get the expected result

        	TInt AppIsRunning(TInt32 aUid, TBool aExpectedResult);

        	// Has FreeRam been called on this plugin since the last call to this function (or since the whole class has been reset)?

        	// Returns KErrNone if we get the expected result

        	TInt PluginFreeRamCalledL(TInt32 aUid, TBool aExpectedResult);

        	// Has FreeRam been called on this plugin since the last call to this function (or since the whole class has been reset)?

        	// Returns KErrNone if we get the expected result

        	TInt PluginMemoryGoodCalledL(TInt32 aUid, TBool aExpectedResult);        

        	// Utility functions

        	// Wait a while for the system to settle down

        	inline void Settle();

        	void BringAppToForeground(TInt32 aUid);

        	TInt GetFreeMemory();

        	// Utility function which calls the async version of optional RAM request and makes it behave like the sync version

        	TInt RequestOptionalRamASyncWrapper(TInt aBytesRequested, TInt aMinimumBytesNeeded, TInt aPluginId, TInt& aBytesAvailable);        	

        	// Utility function which starts the memory monitor property watcher.

        	// The watcher stops the active scheduler when the monitor status changes

        	void StartMemoryMonitorStatusWatcher(TInt& aTestState);

        	// Utility function which starts the timeout watcher and the active scheduler 

			// The watcher stops the active scheduler when the monitor status changes

			// This function also cancels any pending requests when we are done

        	void StartTimerAndRunWatcher(TInt& aTestState);

        	// The tests...

        	// Test normal application closure for a single app

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

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

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

        	TInt AppCloseTest1L(TTestResult& aResult);

        	// 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 AppCloseIdleTimeTest1L(TTestResult& aResult);

        	//Tests the that window group z order is considered when closing apps.

        	//Start 3 apps of equal priority, ensuring their z order is known

        	//Starts another lower priority app and puts that in the foreground

        	//A low memory event is triggered such that only one app needs to be closed

        	//The closed app should be the one furthest from the foreground in the z order

        	TInt AppCloseEqualPrioritiesL(TTestResult& aResult);        	

        	// Test system plugins and continue mode

        	// Simulate a low memory event

        	// Two system plugins should free enough memory, but four will be run because they work in "continue" mode

        	TInt PluginTest1L(TTestResult& aResult);

        	// Test application plugins

        	// Start two target apps

        	// Simulate a low memory event

        	// The one of the application plugins should now be run, displacing one of the system plugins

        	// The target apps are of sufficiently high priority that they will not be closed

        	TInt PluginTest2L(TTestResult& aResult);

        	// Test that the aBytesRequested is correctly passed to the FreeMemory function of V2 plugins

        	// Initialise P4 plugin to consume 5MB of memory

        	// No other plugins are configured to release memory

        	// Simulate a low memory event (go just below the low threshold)

        	// Check that the P4 plugin has been called

        	// Check that the P4 plugin has received a request for > 500K and less than <1500K

        	TInt PluginV2Test1L(TTestResult& aResult);

        	// Test simple prioritisation of application plugins

        	// Start two target applications

        	// Configure all plugins to consume 0.5MB

        	// Simulate a low memory event

        	// Some of the low priority app plugins with those target applications should be called

        	// The highest priority app with that target application should not be called (the lower priority plugins should free enough memory)

        	TInt AppPluginTest1L(TTestResult& aResult);

        	// Test simple prioritisation of application plugins

        	// Start two target applications

        	// Configure all plugins to consume 0.5MB

        	// The app plugin with the highest priority is configured to be assigned the lowest priority after an idle time

        	// Wait until the idle time rule applies

        	// Simulate a low memory event

        	// The plugin that initially had the highest priority (but now has the lowest priority) should be called

        	// Note that this test should be the same as AppPluginTest1L with the addition of the idle period

        	TInt AppPluginIdleTimeTest1L(TTestResult& aResult);	

        	// Test idle time handling for plugins

        	// Start two target apps

        	// Simulate a low memory event

        	// The one of the application plugins should now be run, displacing one of the system plugins

        	// The target apps are of sufficiently high priority that they will not be closed

        	TInt PluginIdleTimeTest2L(TTestResult& aResult);

        	// Test the optional allocation mechanism

        	// Configure the plugins not to release any RAM when FreeRam is called

        	// Configure one priority 7 application to release 12MB when FreeRam is called

        	// Start this application (plus another one so it isn't in the foreground)

        	// Drop just below the good memory level

        	// Request an optional allocation of 10MB referencing a priority 8 plugin

        	// All of the plugins below P8 should be called

        	// The P7 application should be closed freeing the required memory

        	TInt OptionalAllocationTest1L(TTestResult& aResult);

        	// Test the optional allocation mechanism - minimum requested RAM behaviour - successful request

        	// Configure the plugins not to release any RAM when FreeRam is called

        	// Configure one priority 7 application to release 5MB when FreeRam is called

        	// Start this application (plus another one so it isn't in the foreground)

        	// Drop just above the good memory level

        	// Request an optional allocation of 10MB (5MB minimum) referencing a priority 8 plugin

        	// All of the plugins below P8 should be called

        	// The P7 application should be closed freeing the required minimum amount memory

        	// The returned available memory should be about 5MB ( > 3MB and < 7MB )

        	TInt OptionalAllocationTest2L(TTestResult& aResult);

        	// Test the optional allocation mechanism - minimum requested RAM behaviour - failed request

        	// Configure the plugins not to release any RAM when FreeRam is called

        	// Configure one priority 7 application to release 3MB when FreeRam is called

        	// Start this application (plus another one so it isn't in the foreground)

        	// Drop just above the good memory level

        	// Request an optional allocation of 10MB (5MB minimum) referencing a priority 8 plugin

        	// All of the plugins below P8 should be called

        	// The P7 application should be closed but it won't free enough memory

        	// The optional allocation should fail with KErrNoMemory

        	TInt OptionalAllocationTest3L(TTestResult& aResult);

        	// Test that force priority check applies (only) to selected priorities

        	// Setup three plugins (priorities 7, 8 & 9)to eat 5MB each

        	// The configuration file should force a check after priority 8

        	// Drop just under the low threshold

        	// Plugins P7 & P8 should be called (P8 is called even though the P7 plugin freed enough memory)

        	// Plugin P9 should not be called because enou

        	TInt ForcePriorityCheck1L(TTestResult& aResult);

        	// Test the Busy API on the OOM server

        	// Start three applications

        	// Ensure that the lowest priority app is not in the foreground

        	// Call the busy API on the OOM monitor for the lowest priority app

        	// Simulate a low memory event by going just under the low threshold

        	// The busy application should not be closed

        	// The other (non-foreground) application should be closed

        	TInt BusyApplicationTest1L(TTestResult& aResult);

        	// Test the Normal-priority API on the OOM server

        	// Start three applications

        	// Ensure that the lowest priority app is not in the foreground

        	// Call the busy API on the OOM monitor for the lowest priority app

        	// Then call the not-busy API on the OOM monitor for the lowest priority app

        	// Simulate a low memory event by going just under the low threshold

        	// The lowest priority app should be closed (because it is no longer busy)

        	TInt NormalPriorityApplicationTest1L(TTestResult& aResult);

        	// Test the async optional allocation mechanism

        	// Configure the plugins not to release any RAM when FreeRam is called

        	// Configure one priority 7 application to release 12MB when FreeRam is called

        	// Start this application (plus another one so it isn't in the foreground)

        	// Drop just below the good memory level

        	// Request an optional allocation of 10MB referencing a priority 8 plugin

        	// All of the plugins below P8 should be called

        	// The P7 application should be closed freeing the required memory

        	TInt OptionalAllocationAsyncTest1L(TTestResult& aResult);

        	// Test the async optional allocation mechanism - minimum requested RAM behaviour - successful request

        	// Configure the plugins not to release any RAM when FreeRam is called

        	// Configure one priority 7 application to release 5MB when FreeRam is called

        	// Start this application (plus another one so it isn't in the foreground)

        	// Drop just above the good memory level

        	// Request an optional allocation of 10MB (5MB minimum) referencing a priority 8 plugin

        	// All of the plugins below P8 should be called

        	// The P7 application should be closed freeing the required minimum amount memory

        	// The returned available memory should be about 5MB ( > 3MB and < 7MB )

        	TInt OptionalAllocationAsyncTest2L(TTestResult& aResult);

        	// Test the async optional allocation mechanism - minimum requested RAM behaviour - failed request

        	// Configure the plugins not to release any RAM when FreeRam is called

        	// Configure one priority 7 application to release 3MB when FreeRam is called

        	// Start this application (plus another one so it isn't in the foreground)

        	// Drop just above the good memory level

        	// Request an optional allocation of 10MB (5MB minimum) referencing a priority 8 plugin

        	// All of the plugins below P8 should be called

        	// The P7 application should be closed but it won't free enough memory

        	// The optional allocation should fail with KErrNoMemory

        	TInt OptionalAllocationAsyncTest3L(TTestResult& aResult);

        	// Test that sync mode configuration is working for system plugins

        	// Configure three system plugins to release 5MB of memory each.

        	// The plugins are configured as follows

        	// Plugin 1: Priority 7, sync mode continue

        	// Plugin 2: Priority 8, sync mode check

        	// Plugin 3: Priority 9, sync mode continue

        	// Drop just under the low threshold

        	// Plugins 1 & 2 should be called (even though plugin 1 alone has freed enough RAM)

        	// Plugin 3 won't be called because the check on the priority 8 plugin discovers that enough RAM has been freed

        	TInt PluginSyncModeTest1L(TTestResult& aResult);	

        	// Start three applications

        	// One is set to NEVER_CLOSE, one is low priority, one is a dummy app to ensure that the first two are not in the foreground

        	// Configure applications not to release any memory

        	// Go just significantly under the low memory threshold

        	// Wait for the system to recover, if we have moved above the low memory threshold then go significantly under it again. Repeat this step until we no longer go above low.

        	// Check that the low priority application is closed

        	// Check that the NEVER_CLOSE application is not closed (even though we're still below the low theshold)

        	TInt NeverCloseTest1L(TTestResult& aResult);

        	TInt AppCloseTwoSessionsL(TTestResult& aResult);

            TInt CallIfTargetAppNotRunningTest1L(TTestResult& aResult);            	

            TInt AppCloseSpecificThresholdTest1L(TTestResult& aResult);

            // test that the plugins are left in the off state if a request for optional RAM 

            // cannot be granted

            TInt PluginTestInsufficientMemoryFreedL(TTestResult& aResult);

            // test that the plugins are left in the off state if a request for optional RAM 

            // cannot be granted

            // The test makes the optional RAM call from a state where memory is between the 

            // global low and good thresholds

            TInt PluginTestInsufficientMemoryFreed2L(TTestResult& aResult);