// Copyright (c) 1996-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:

// Out of memory tests

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "TOOM.H"

typedef COomFailBase *(*COmmCreate)(CTOom *aTest);

COomFailBase *CreateOomConnect(CTOom *aTest)

	{return(new(ELeave) COomConnect(aTest));}

COomFailBase *CreateOomWindow(CTOom *aTest)

	{return(new(ELeave) COomWindow(aTest));}

COomFailBase *CreateOomWindowGroup(CTOom *aTest)

	{return(new(ELeave) COomWindowGroup(aTest));}

COomFailBase *CreateOomBackedUpWindow(CTOom *aTest)

	{return(new(ELeave) COomBackedUpWindow(aTest));}

COomFailBase *CreateOomBackupResize(CTOom *aTest)

	{return(new(ELeave) COomBackupResize(aTest));}

COomFailBase *CreateOomBlankWindow(CTOom *aTest)

	{return(new(ELeave) COomBlankWindow(aTest));}

COomFailBase *CreateOomGc(CTOom *aTest)

	{return(new(ELeave) COomGc(aTest));}

COomFailBase *CreateOomScreenDevice(CTOom *aTest)

	{return(new(ELeave) COomScreenDevice(aTest));}

COomFailBase *CreateOomPointerBuffer(CTOom *aTest)

	{return(new(ELeave) COomPointerBuffer(aTest));}

COomFailBase *CreateOomPolygon(CTOom *aTest)

	{return(new(ELeave) COomPolygon(aTest));}

COomFailBase *CreateOomPriorityKey(CTOom *aTest)

	{return(new(ELeave) COomPriorityKey(aTest));}

COomFailBase *CreateOomCaptureKey(CTOom *aTest)

	{return(new(ELeave) COomCaptureKey(aTest));}

COomFailBase *CreateOomCaptureKeyUpDown(CTOom *aTest)

	{return(new(ELeave) COomCaptureKeyUpDown(aTest));}

COomFailBase *CreateOomHotKey(CTOom *aTest)

	{return(new(ELeave) COomHotKey(aTest));}

COomFailBase *CreateOomGroupName(CTOom *aTest)

	{return(new(ELeave) COomGroupName(aTest));}

COomFailBase *CreateOomMessageSend(CTOom *aTest)

	{return(new(ELeave) COomMessageSend(aTest));}

COomFailBase *CreateOomMessageFetch(CTOom *aTest)

	{return(new(ELeave) COomMessageFetch(aTest));}

COomFailBase *CreateOomSprite(CTOom *aTest)

	{return(new(ELeave) COomSprite(aTest));}

COomFailBase *CreateOomPointerCursor(CTOom *aTest)

	{return(new(ELeave) COomPointerCursor(aTest));}

COomFailBase *CreateOomCopyScreen(CTOom *aTest)

	{return(new(ELeave) COomCopyScreen(aTest));}

COomFailBase *CreateOomRequestEvents(CTOom *aTest)

	{return(new(ELeave) COomRequestEvents(aTest));}

COomFailBase *CreateOomCustomTextCursor(CTOom *aTest)

	{return(new(ELeave) COomCustomTextCursor(aTest));}

COomFailBase *CreateOomTranspWindow(CTOom *aTest)

	{return(new(ELeave) COomTranspWindow(aTest));}

COomFailBase *CreateOomObscuredWindow(CTOom *aTest)

	{return(new(ELeave) COomObscuredWindow(aTest));}

COmmCreate CreateOomFailTest[]={

	CreateOomConnect,

	CreateOomWindow,

	CreateOomWindowGroup,

	CreateOomBackedUpWindow,

	CreateOomBackupResize,

	CreateOomBlankWindow,

	CreateOomGc,

	CreateOomScreenDevice,

	CreateOomPointerBuffer,

	CreateOomPolygon,

	CreateOomPriorityKey,

	CreateOomCaptureKey,

	CreateOomCaptureKeyUpDown,

	CreateOomHotKey,

	CreateOomGroupName,

	CreateOomSprite,

	CreateOomPointerCursor,

	CreateOomCopyScreen,

	CreateOomRequestEvents,

	CreateOomMessageSend,

	CreateOomMessageFetch,

	CreateOomCustomTextCursor,

	CreateOomTranspWindow,

	CreateOomObscuredWindow,

	};

//

// Individual out of memory test classes //

//

COomFailBase::COomFailBase(CTOom *aTest) : iTest(aTest)

	{}

void COomFailBase::ConstructL()

	{

	iTest->INFO_PRINTF1(TestName());

	}

void COomFailBase::PreFail()

	{}

void COomFailBase::ClearUpL()

	{}

void COomFailBase::Flush()

	{

	iWs.Flush();

	}

COomConnect::COomConnect(CTOom *aTest) : COomFailBase(aTest)

	{}

TOomTestName COomConnect::TestName()

	{

	return(_L("Connect"));

	}

/** Creates a wserv session, connects and creates CWsScreenDevice object

*/

TInt COomConnect::Fail()

	{

	TInt err = iWs.Connect();

	if (err!=KErrNone)

		return err;

	TRAP(err, iDummyScreen = new (ELeave) CWsScreenDevice(iWs));

	if (err!=KErrNone)

		{

		iWs.Close();

		return err;

		}

	if ((err=iDummyScreen->Construct(iTest->ScreenNumber()))!=KErrNone)

		{

		delete iDummyScreen;

		iDummyScreen = NULL;

		iWs.Close();

		return err;

		}

	return err;

	}

void COomConnect::ClearUpL()

	{

	if (iDummyScreen)

		{

		delete iDummyScreen;

		iDummyScreen = NULL;

		}

	iWs.Close();

	}

//

COomSetup::COomSetup(CTOom *aTest) : COomFailBase(aTest)

	{}

void COomSetup::ConstructL()

	{

	COomFailBase::ConstructL();

	User::LeaveIfError(iWs.Connect());

	iDummyScreen = new (ELeave) CWsScreenDevice(iWs);

	User::LeaveIfError(iDummyScreen->Construct(iTest->ScreenNumber()));

	iWinGroup=RWindowGroup(iWs);

	iWinGroup.Construct(556);

	iWinGroup.EnableReceiptOfFocus(EFalse);	// Stop auto group switching on close

	}

COomSetup::~COomSetup()

	{

	iWinGroup.Close();

	delete iDummyScreen;

	iDummyScreen = NULL;

	iTest->TEST(iWs.ResourceCount()==0);

	if (iWs.ResourceCount()!=0)

		iTest->INFO_PRINTF3(_L("iWs.ResourceCount() return value - Expected: %d, Actual: %d"), 0, iWs.ResourceCount());			

	iWs.Close();

	}

//

COomWindowGroup::COomWindowGroup(CTOom *aTest) : COomSetup(aTest)

	{}

TOomTestName COomWindowGroup::TestName()

	{

	return(_L("Window Group"));

	}

/** Creates a RWindowGroup object

*/

TInt COomWindowGroup::Fail()

	{

	iFailWinGroup=RWindowGroup(iWs);

	return(iFailWinGroup.Construct(987));

	}

void COomWindowGroup::ClearUpL()

	{

	iFailWinGroup.Close();

	}

//

COomWindow::COomWindow(CTOom *aTest) : COomSetup(aTest)

	{}

TOomTestName COomWindow::TestName()

	{

	return(_L("Window"));

	}

/** Creates a RWindow object

*/

TInt COomWindow::Fail()

	{

	iFailWin=RWindow(iWs);

	return(iFailWin.Construct(iWinGroup,11));

	}

void COomWindow::ClearUpL()

	{

	iFailWin.Close();

	}

//

COomBackedUpWindow::COomBackedUpWindow(CTOom *aTest) : COomSetup(aTest)

	{}

TOomTestName COomBackedUpWindow::TestName()

	{

	return(_L("Backed up window"));

	}

/** Creates a RBackedUpWindow object

*/

TInt COomBackedUpWindow::Fail()

	{

	iFailWin=RBackedUpWindow(iWs);

	return(iFailWin.Construct(iWinGroup,EGray16,22));

	}

void COomBackedUpWindow::ClearUpL()

	{

	iFailWin.Close();

	}

//

COomBackupResize::COomBackupResize(CTOom *aTest) : COomSetup(aTest)

	{}

COomBackupResize::~COomBackupResize()

	{

	iFailWin.Close();

	}

TOomTestName COomBackupResize::TestName()

	{

	return(_L("Resize backed up window"));

	}

void COomBackupResize::ConstructL()

	{

	COomSetup::ConstructL();

	iFailWin=RBackedUpWindow(iWs);

	User::LeaveIfError(iFailWin.Construct(iWinGroup,EGray16,33));

	User::LeaveIfError(iFailWin.SetSizeErr(TSize(10,10)));

	iFailWin.Activate();

	}

/** Sets the size of previously created backed-up window

*/

TInt COomBackupResize::Fail()

	{

	return(iFailWin.SetSizeErr(TSize(100,100)));

	}

void COomBackupResize::ClearUpL()

//Virtual fn declared in CoomFailBase. This is the only one that can leave, I think, but one is enough

	{

	User::LeaveIfError(iFailWin.SetSizeErr(TSize(10,10)));

	}

//

COomBlankWindow::COomBlankWindow(CTOom *aTest) : COomSetup(aTest)

	{}

TOomTestName COomBlankWindow::TestName()

	{

	return(_L("Blank window"));

	}

/** Creates a RBlankWindow object

*/

TInt COomBlankWindow::Fail()

	{

	iFailWin=RBlankWindow(iWs);

	return(iFailWin.Construct(iWinGroup,44));

	}

void COomBlankWindow::ClearUpL()

	{

	iFailWin.Close();

	}

//

COomPointerBuffer::COomPointerBuffer(CTOom *aTest) : COomSetup(aTest)

	{}

COomPointerBuffer::~COomPointerBuffer()

	{

	iFailWin.Close();

	}

TOomTestName COomPointerBuffer::TestName()

	{

	return(_L("Pointer buffer"));

	}

void COomPointerBuffer::ConstructL()

	{

	COomSetup::ConstructL();

	iFailWin=RBackedUpWindow(iWs);

	User::LeaveIfError(iFailWin.Construct(iWinGroup,EGray16,55));

	User::LeaveIfError(iFailWin.SetSizeErr(TSize(10,10)));

	iFailWin.Activate();

	}

/** Allocates a buffer for storing pointer movements for previously created backed-up window

*/

TInt COomPointerBuffer::Fail()

	{

	return(iFailWin.AllocPointerMoveBuffer(10,0));

	}

void COomPointerBuffer::ClearUpL()

	{

	iFailWin.FreePointerMoveBuffer();

	}

//

COomPriorityKey::COomPriorityKey(CTOom *aTest) : COomSetup(aTest)

	{}

COomPriorityKey::~COomPriorityKey()

	{

	}

TOomTestName COomPriorityKey::TestName()

	{

	return(_L("Priority key"));

	}

void COomPriorityKey::ConstructL()

	{

	COomSetup::ConstructL();

	}

/** Adds a priority key for a previously created window group

*/

TInt COomPriorityKey::Fail()

	{

	return(iWinGroup.AddPriorityKey(1,0,0));

	}

void COomPriorityKey::ClearUpL()

	{

	iWinGroup.RemovePriorityKey(1,0,0);

	}

//

COomCaptureKey::COomCaptureKey(CTOom *aTest) : COomSetup(aTest)

	{}

COomCaptureKey::~COomCaptureKey()

	{

	}

TOomTestName COomCaptureKey::TestName()

	{

	return(_L("Capture key"));

	}

void COomCaptureKey::ConstructL()

	{

	COomSetup::ConstructL();

	}

/** Requests a capture keys for a previously created window group

*/

TInt COomCaptureKey::Fail()

	{

	for (iIndex=0;iIndex<(TInt)(sizeof(iCapKey)/sizeof(iCapKey[0]));iIndex++)

		{

		TInt ret=iWinGroup.CaptureKey('a',0,0);

		if (ret<0)

			return(ret);

		iCapKey[iIndex]=ret;

		}

	return(KErrNone);

	}

void COomCaptureKey::ClearUpL()

	{

	for (TInt index=0;index<iIndex;index++)

		iWinGroup.CancelCaptureKey(iCapKey[index]);

	}

//

COomCaptureKeyUpDown::COomCaptureKeyUpDown(CTOom *aTest) : COomSetup(aTest)

	{}

COomCaptureKeyUpDown::~COomCaptureKeyUpDown()

	{

	}

TOomTestName COomCaptureKeyUpDown::TestName()

	{

	return(_L("Capture up/down keys"));

	}

void COomCaptureKeyUpDown::ConstructL()

	{

	COomSetup::ConstructL();

	}

/** Requests the capture of key-up and key-down events for a previously created window group

*/

TInt COomCaptureKeyUpDown::Fail()

	{

	for (iIndex=0;iIndex<(TInt)(sizeof(iCapKey)/sizeof(iCapKey[0]));iIndex++)

		{

		TInt ret=iWinGroup.CaptureKeyUpAndDowns('a',0,0);

		if (ret<0)

			return(ret);

		iCapKey[iIndex]=ret;

		}

	return(KErrNone);

	}

void COomCaptureKeyUpDown::ClearUpL()

	{

	for (TInt index=0;index<iIndex;index++)

		iWinGroup.CancelCaptureKeyUpAndDowns(iCapKey[index]);

	}

//

COomHotKey::COomHotKey(CTOom *aTest) : COomSetup(aTest)

	{}

COomHotKey::~COomHotKey()

	{

	}

TOomTestName COomHotKey::TestName()

	{

	return(_L("hot keys"));

	}

void COomHotKey::ConstructL()

	{

	COomSetup::ConstructL();

	}

/** Sets hot key for the session.

*/

TInt COomHotKey::Fail()

	{

	return(iWs.SetHotKey(EHotKeyEnableLogging,'a',0,0));

	}

void COomHotKey::ClearUpL()

	{

	iWs.RestoreDefaultHotKey(EHotKeyEnableLogging);