/*

* Copyright (c) 2006-2010 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 Files  

#include "t_oomharness.h"

#include "CDummyApplicationHandle.h"

#include "cleanuputils.h"

#include "t_oomdummyplugin_properties.h"

#include <e32base.h>

#include <e32std.h>

#include <e32cons.h>			// Console

#include <e32hal.h>

#include <e32property.h>

#include <e32cmn.h>

#include <hal.h>

#include "t_oomdummyplugin_properties.h"

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

//  Constants

_LIT(KTextConsoleTitle, "Console");

_LIT(KTextFailed, " failed, leave code = %d");

_LIT(KTextPressAnyKey, " [press any key]\n");

const TInt KOomLowMemoryThreshold = 4096;

const TInt KOomJustUnderLowMemoryThreshold = 4000;

const TInt KOomSignificantlyUnderLowMemoryThreshold = 2024;

const TInt KOomJustAboveGoodMemoryThreshold = 5100;

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

const TInt KOomTestFirstIdlePeriod = 40000000; // 40 seconds

const TInt KOomHarnessMaxEatenMemory = 64 * 1024 * 1024;

//  Global Variables

LOCAL_D CConsoleBase* console; // write all messages to this

void COomTestHarness::StartL()

	{

	ResetL();

	TInt err = KErrNone;

	TBool testsFailed = EFalse;

	err = AppCloseTest1L();

	if (err != KErrNone)

		testsFailed = ETrue;

	ResetL();

	err = AppCloseIdleTimeTest1L();

	if (err != KErrNone)

		testsFailed = ETrue;

	ResetL();

	err = PluginTest1L();

	if (err != KErrNone)

		testsFailed = ETrue;

	ResetL();

	err = PluginTest2L();

	if (err != KErrNone)

		testsFailed = ETrue;

	ResetL();

	err = AppPluginTest1L();

	if (err != KErrNone)

		testsFailed = ETrue;

	ResetL();

	err = AppPluginIdleTimeTest1L();

	if (err != KErrNone)

		testsFailed = ETrue;

	ResetL();

	err = OptionalAllocationTest1L();

	if (err != KErrNone)

		testsFailed = ETrue;

	ResetL();	

	err = OptionalAllocationTest2L();

	if (err != KErrNone)

		testsFailed = ETrue;

	ResetL();	

	err = OptionalAllocationTest3L();

	if (err != KErrNone)

		testsFailed = ETrue;

	ResetL();

	err = PluginV2Test1L();

	if (err != KErrNone)

		testsFailed = ETrue;

	ResetL();

	err = ForcePriorityCheck1L();

	if (err != KErrNone)

		testsFailed = ETrue;

	ResetL();

	err = PluginSyncModeTest1L();

	if (err != KErrNone)

		testsFailed = ETrue;

	ResetL();

	err = NeverCloseTest1L();

	if (err != KErrNone)

		testsFailed = ETrue;

	ResetL();

	err = OptionalAllocationAsyncTest1L();

	if (err != KErrNone)

		testsFailed = ETrue;

	ResetL();	

	err = OptionalAllocationAsyncTest2L();

	if (err != KErrNone)

		testsFailed = ETrue;

	ResetL();	

	err = OptionalAllocationAsyncTest3L();

	if (err != KErrNone)

		testsFailed = ETrue;

	ResetL();

//	if (err == KErrNone)

//		err = BusyApplicationTest1L();

	ResetL();

//	if (err == KErrNone)

//		err = NormalPriorityApplicationTest1L();

	if (!testsFailed)

		console->Printf(_L("All tests passed\n"));

	else

		console->Printf(_L("Tests failed\n"));

	}

// 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 and highest priority application should be configured to eat 5MB of memory

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

TInt COomTestHarness::AppCloseTest1L()

	{

	// 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(0x101f8599, 5 * 1024); // P9 app

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

	StartApplicationL(0x10005a22, 0); // P7 app

	BringAppToForeground(0x10005a22);

	Settle();

	// Go significantly under the low memory threshold

	EatMemoryL(KOomSignificantlyUnderLowMemoryThreshold);

	Settle();

	TInt err = KErrNone;

	// The P8 application should be closed

	err = AppIsRunning(0x10005901, EFalse);

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

	if (err == KErrNone)

		err = AppIsRunning(0x10005a22, ETrue);	

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

	if (err == KErrNone)

		err = AppIsRunning(0x101f8599, ETrue);	

	if (err == KErrNone)

		console->Printf(_L("App Close Test 1 passed\n"));

	else

		console->Printf(_L("App Close Test 1 failed\n"));	

	return err;

	}

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

	{

	// 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(0x101f8599, 5 * 1024); // P9 app (which becomes a P2 app after the idle time)

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

	StartApplicationL(0x10005a22, 0); // P7 app

	BringAppToForeground(0x10005a22);

	Settle();

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

	User::After(KOomTestFirstIdlePeriod);

	// Go significantly under the low memory threshold

	EatMemoryL(KOomSignificantlyUnderLowMemoryThreshold);

	Settle();

	// The first two system plugins should have been closed, releasing the required memory

	// The following two system plugins won't be called (the app plugins will now take their place)

	TInt 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

	if (err == KErrNone)

		err = AppIsRunning(0x101f8599, EFalse);		

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

	err = AppIsRunning(0x10005901, ETrue);

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

	if (err == KErrNone)

		err = AppIsRunning(0x10005a22, ETrue);	

	if (err == KErrNone)

		console->Printf(_L("App Close Idle Time Test 1 passed\n"));

	else

		console->Printf(_L("App Close Idle Time Test 1 failed\n"));	

	return err;

	}

TInt COomTestHarness::PluginTest1L()

	{

	// Configure the plugins to eat 0.5MB each:

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

		{

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

		}

	Settle();

	// Go just under the low memory threshold

	EatMemoryL(KOomJustUnderLowMemoryThreshold);

	Settle();

	// The first four system plugins should have been run, releasing the required memory

	// All four plugins should be called, even though the first two will release enough memory (this is because

	// plugins are always run in continue mode)

	TInt err = KErrNone;

	err = PluginFreeRamCalledL(KUidOOMDummyPluginFirstImplementation, ETrue);

	if (err == KErrNone)

		err = PluginFreeRamCalledL(KUidOOMDummyPluginFirstImplementation + 1, ETrue);

	if (err == KErrNone)

		err = PluginFreeRamCalledL(KUidOOMDummyPluginFirstImplementation + 2, ETrue);

	if (err == KErrNone)

		err = PluginFreeRamCalledL(0x10286A3C, ETrue);

	// Finally check that the plugins have been notified of the final good memory state

	if (err == KErrNone)

		err = PluginMemoryGoodCalledL(KUidOOMDummyPluginFirstImplementation, ETrue);

	if (err == KErrNone)

		err = PluginMemoryGoodCalledL(KUidOOMDummyPluginFirstImplementation + 1, ETrue);

	if (err == KErrNone)

		err = PluginMemoryGoodCalledL(KUidOOMDummyPluginFirstImplementation + 2, ETrue);

	if (err == KErrNone)

		err = PluginMemoryGoodCalledL(0x10286A3C, ETrue);

	if (err == KErrNone)

		console->Printf(_L("Plugin Test 1 passed\n"));

	else

		console->Printf(_L("Plugin Test 1 failed\n"));	

	return err;

	}

// 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 COomTestHarness::PluginTest2L()

	{

	// Configure the plugins to eat 0.5MB each:

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

		{

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

		}

	// Start the two target applications (plus a third so that the target apps are not in the foreground)

	StartApplicationL(0x10005901, 0);

	StartApplicationL(0x10005a22, 0);

	StartApplicationL(0x101f8599, 0);

	BringAppToForeground(0x101f8599);

	Settle();

	// Go just under the low memory threshold

	EatMemoryL(KOomJustUnderLowMemoryThreshold);

	Settle();

	// The first two system plugins should have been closed, releasing the required memory

	// The following two system plugins won't be called (the app plugins will now take their place)

	TInt err = KErrNone;

	// The following plugins should be called...

	// Application plugins: 10286A3A 10286A3B

	// System plugins: 10286A3C(v2 plugin) 10286A34

	if (err == KErrNone)

		err = PluginFreeRamCalledL(0x10286A3B, ETrue);

	if (err == KErrNone)

		err = PluginFreeRamCalledL(0x10286A3A, ETrue);

	// Plugins and apps with higher priorities will not be called/closed because 0x10286A3A is configured to check memory before running anything else

	if (err == KErrNone)

		err = PluginFreeRamCalledL(0x10286A3C, EFalse);

	if (err == KErrNone)

		err = PluginFreeRamCalledL(0x10286A34, EFalse);

	if (err == KErrNone)

		err = PluginFreeRamCalledL(0x10286A35, EFalse);	

	if (err == KErrNone)

		err = AppIsRunning(0x10005a22, ETrue);		

	if (err == KErrNone)

		err = AppIsRunning(0x10005901, ETrue);

	if (err == KErrNone)

		err = AppIsRunning(0x101f8599, ETrue);		

	if (err == KErrNone)

		console->Printf(_L("Plugin Test 2 passed\n"));

	else

		console->Printf(_L("Plugin Test 2 failed\n"));	

	return err;

	}

// 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 COomTestHarness::PluginV2Test1L()

	{

	// Configure the P4 V2 plugin to eat 5MB:

	User::LeaveIfError(iAllocServer.Configure(TUid::Uid(0x10286A3C), 0, 0x500000, 0x500000));

	Settle();

	// Go just under the low memory threshold

	EatMemoryL(KOomJustUnderLowMemoryThreshold);

	Settle();

	// The first four system plugins should have been closed, releasing the required memory

	// All four plugins should be called, even though the first two will release enough memory (this is because

	// plugins are always run in continue mode)

	TInt err = KErrNone;

	// Check that the P4 plugin has been called

	err = PluginFreeRamCalledL(0x10286A3C, ETrue);

	// Check that the request for memory was about right

	// Note: regular system variation makes it impossible to test for an exact number

	TInt requestedMemory = 0;

	err = RProperty::Get(KUidOomPropertyCategory, 0x10286A3C + KOOMDummyPluginBytesRequested, requestedMemory);

	if ((requestedMemory < 512 * 1024)

			|| (requestedMemory > 1500 * 1024))

		err = KErrGeneral;

	// Check that the higher priority V2 plugin has not been called

	if (err == KErrNone)

		err = PluginFreeRamCalledL(0x10286A3D, EFalse);

	if (err == KErrNone)

		console->Printf(_L("Plugin V2 Test 1 passed\n"));

	else

		console->Printf(_L("Plugin V2 Test 1 failed\n"));	

	return err;

	}

// 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 COomTestHarness::AppPluginTest1L()

	{

	// Configure the plugins to eat 0.5MB each:

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

		{

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

		}

	// Start the two target applications (plus a third so that the target apps are not in the foreground)

	StartApplicationL(0x10005901, 0);

	StartApplicationL(0x10005a22, 0);

	StartApplicationL(0x101f8599, 0);

	TInt err = KErrNone;

	// Check that all of the apps are running

	if (err == KErrNone)

		err = AppIsRunning(0x10005901, ETrue);

	if (err == KErrNone)

		err = AppIsRunning(0x10005a22, ETrue);

	if (err == KErrNone)

		err = AppIsRunning(0x101f8599, ETrue);

	if (err == KErrNone)

		console->Printf(_L("Apps started\n"));

	else

		console->Printf(_L("Apps not started\n"));

	BringAppToForeground(0x101f8599);

	Settle();

	// Go just under the low memory threshold

	EatMemoryL(KOomJustUnderLowMemoryThreshold);

	Settle();

	// The following application plugins should be called...

	// Application plugins: 10286A3A 10286A3B

	if (err == KErrNone)

		err = PluginFreeRamCalledL(0x10286A3A, ETrue);

	if (err == KErrNone)

		err = PluginFreeRamCalledL(0x10286A3B, ETrue);

	// The following plugin should not be called because other plugins (including some unchecked system plugins) have freed enough memory

	// 10286A38

	if (err == KErrNone)

		err = PluginFreeRamCalledL(0x10286A38, EFalse);	

	if (err == KErrNone)

		console->Printf(_L("App Plugin Test 1 passed\n"));

	else

		console->Printf(_L("App Plugin Test 1 failed\n"));	

	return err;

	}

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