--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/tauto/TOOM.CPP	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,1583 @@
+// 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);
+	}
+
+//
+
+COomGroupName::COomGroupName(CTOom *aTest) : COomSetup(aTest)
+	{}
+
+COomGroupName::~COomGroupName()
+	{
+	}
+
+TOomTestName COomGroupName::TestName()
+	{
+	return(_L("Group name"));
+	}
+
+void COomGroupName::ConstructL()
+	{
+	COomSetup::ConstructL();
+	}
+
+/** Sets the window group's name.
+*/
+TInt COomGroupName::Fail()
+	{
+	return(iWinGroup.SetName(_L("A Name")));
+	}
+
+void COomGroupName::ClearUpL()
+	{
+	iWinGroup.SetName(_L(""));
+	}
+
+//
+
+COomMessageSend::COomMessageSend(CTOom *aTest) : COomSetup(aTest)
+	{}
+
+COomMessageSend::~COomMessageSend()
+	{
+	}
+
+TOomTestName COomMessageSend::TestName()
+	{
+	return(_L("MessageSend"));
+	}
+
+void COomMessageSend::ConstructL()
+	{
+	COomSetup::ConstructL();
+	}
+
+void COomMessageSend::PreFail()
+	{
+	iWinGroup2=RWindowGroup(iWs);
+	iWinGroup2.Construct(557);
+	iWinGroup2.EnableReceiptOfFocus(EFalse);	// Stop auto group switching on close
+	}
+
+/** Sends a message to another window group
+*/
+TInt COomMessageSend::Fail()
+	{
+	TBuf8<0x20> params(_L8("SomeParams"));
+	return(iWs.SendMessageToWindowGroup(iWinGroup2.Identifier(),TUid::Uid(123),params));
+	}
+
+void COomMessageSend::ClearUpL()
+	{
+	iWinGroup2.Close();
+	}
+
+//
+
+COomMessageFetch::COomMessageFetch(CTOom *aTest) : COomSetup(aTest)
+	{}
+
+COomMessageFetch::~COomMessageFetch()
+	{
+	}
+
+TOomTestName COomMessageFetch::TestName()
+	{
+	return(_L("MessageFetch"));
+	}
+
+void COomMessageFetch::ConstructL()
+	{
+	COomSetup::ConstructL();
+	}
+
+#define CLIENT_HANDLE 555
+#define UID_VALUE 123
+#define MESSAGE_LEN 0x20
+void COomMessageFetch::PreFail()
+	{
+	iWinGroup2=RWindowGroup(iWs);
+	iWinGroup2.Construct(CLIENT_HANDLE);
+	iWinGroup2.EnableReceiptOfFocus(EFalse);	// Stop auto group switching on close
+	TBuf8<MESSAGE_LEN> params(_L8("SomeParams"));
+	TBool retVal = iWs.SendMessageToWindowGroup(iWinGroup2.Identifier(),TUid::Uid(UID_VALUE),params);
+	iTest->TEST(retVal==KErrNone);
+	if (retVal!=KErrNone)
+		iTest->INFO_PRINTF3(_L("iWs.SendMessageToWindowGroup() return value - Expected: %d, Actual: %d"), KErrNone, retVal);			
+	}
+
+/** Fetches a message
+*/
+TInt COomMessageFetch::Fail()
+	{
+	TWsEvent event;
+	TPtr8 ptr(NULL,0);
+	TUid uid;
+	event.SetType(EEventMessageReady);
+	event.SetHandle(CLIENT_HANDLE);
+	event.SetTimeNow();
+	SEventMessageReady& eventMessageReady=*(SEventMessageReady*)event.EventData();
+	eventMessageReady.iWindowGroupIdentifier=iWinGroup2.Identifier();
+	eventMessageReady.iMessageUid=TUid::Uid(UID_VALUE);
+	eventMessageReady.iMessageParametersSize=MESSAGE_LEN;
+	TInt ret=TheClient->iWs.FetchMessage(uid,ptr,event);
+	if (ret==KErrNone)
+		User::Free((TAny *)ptr.Ptr());
+	return(ret);
+	}
+
+void COomMessageFetch::ClearUpL()
+	{
+	iWinGroup2.Close();
+	}
+
+//
+
+COomRequestEvents::COomRequestEvents(CTOom *aTest) : COomSetup(aTest)
+	{}
+
+COomRequestEvents::~COomRequestEvents()
+	{
+	}
+
+TOomTestName COomRequestEvents::TestName()
+	{
+	return(_L("Request events"));
+	}
+
+void COomRequestEvents::ConstructL()
+	{
+	COomSetup::ConstructL();
+	}
+
+/** Enables window group change events and modifier change events
+*/
+TInt COomRequestEvents::Fail()
+	{
+	TInt err;
+	if ((err=iWinGroup.EnableOnEvents())==KErrNone)
+		if ((err=iWinGroup.EnableGroupChangeEvents())==KErrNone)
+			err=iWinGroup.EnableModifierChangedEvents(EModifierCapsLock,EEventControlAlways);
+	return(err);
+	}
+
+void COomRequestEvents::ClearUpL()
+	{
+	iWinGroup.DisableOnEvents();
+	iWinGroup.DisableGroupChangeEvents();
+	iWinGroup.DisableModifierChangedEvents();
+	}
+
+//
+
+COomCopyScreen::COomCopyScreen(CTOom *aTest) : COomSetup(aTest)
+	{}
+
+TOomTestName COomCopyScreen::TestName()
+	{
+	return(_L("Copy screen"));
+	}
+
+COomCopyScreen::~COomCopyScreen()
+	{
+	delete iScrDev;
+	delete iBitmap;
+	}
+
+void COomCopyScreen::ConstructL()
+	{
+	COomSetup::ConstructL();
+	iScrDev=new(ELeave) CWsScreenDevice(iWs);
+	User::LeaveIfError(iScrDev->Construct(iTest->ScreenNumber()));
+	iBitmap=new(ELeave) CFbsBitmap();
+	User::LeaveIfError(iBitmap->Create(TSize(100,100),EGray4));
+	}
+
+/** Copies screen to bitmap
+*/
+TInt COomCopyScreen::Fail()
+	{
+	TInt ret=iScrDev->CopyScreenToBitmap(iBitmap);
+	if (ret==KErrNone)
+		ret=iScrDev->CopyScreenToBitmap(iBitmap,TRect(10,10,50,50));
+	return(ret);
+	}
+
+void COomCopyScreen::ClearUpL()
+	{
+	}
+
+//
+
+COomSpriteBase::COomSpriteBase(CTOom *aTest) : COomSetup(aTest)
+	{}
+
+COomSpriteBase::~COomSpriteBase()
+	{
+	iWin.Close();
+	delete iBitmap;
+	delete iMask;
+	delete iBitmap2;
+	delete iMask2;
+	}
+
+void COomSpriteBase::ConstructL()
+	{
+	COomSetup::ConstructL();
+	iWin=RWindow(iWs);
+	User::LeaveIfError(iWin.Construct(iWinGroup,33));
+	User::LeaveIfError(iWin.SetSizeErr(TSize(100,100)));
+	iWin.Activate();
+	iBitmap=new(ELeave) CFbsBitmap();
+	User::LeaveIfError(iBitmap->Create(TSize(10,10),EGray4));
+	iBitmap2=new(ELeave) CFbsBitmap();
+	User::LeaveIfError(iBitmap2->Create(TSize(40,40),EGray4));
+	iMask=new(ELeave) CFbsBitmap();
+	User::LeaveIfError(iMask->Create(TSize(10,10),EGray4));
+	iMask2=new(ELeave) CFbsBitmap();
+	User::LeaveIfError(iMask2->Create(TSize(40,40),EGray4));
+	}
+
+//
+
+COomSprite::COomSprite(CTOom *aTest) : COomSpriteBase(aTest)
+	{}
+
+TOomTestName COomSprite::TestName()
+	{
+	return(_L("Sprites"));
+	}
+
+/** Creates a sprite.
+*/
+TInt COomSprite::Fail()
+	{
+	iSprite=RWsSprite(iWs);
+	TInt err=iSprite.Construct(iWin,TPoint(10,10),0);
+	if (err==KErrNone)
+		{
+		TSpriteMember sprite;
+		sprite.iBitmap=iBitmap;
+		sprite.iMaskBitmap=iMask;
+		sprite.iInvertMask=EFalse;
+		sprite.iDrawMode=CGraphicsContext::EDrawModePEN;
+		sprite.iOffset=TPoint(0,0);
+		sprite.iInterval=TTimeIntervalMicroSeconds32(100000);
+		if ((err=iSprite.AppendMember(sprite))==KErrNone)
+			if ((err=iSprite.Activate())==KErrNone)
+				{
+				sprite.iBitmap=iBitmap2;		// Bigger bitmap to force resize of bitmap
+				sprite.iMaskBitmap=iMask2;
+				if ((err=iSprite.AppendMember(sprite))==KErrNone)
+					err=iSprite.UpdateMember(1,sprite);
+				}
+		}
+	return(err);
+	}
+
+void COomSprite::ClearUpL()
+	{
+	iSprite.Close();
+	}
+
+//
+
+COomPointerCursor::COomPointerCursor(CTOom *aTest) : COomSpriteBase(aTest)
+	{}
+
+TOomTestName COomPointerCursor::TestName()
+	{
+	return(_L("Pointer cursor"));
+	}
+
+/** Creates a pointer cursor.
+*/
+TInt COomPointerCursor::Fail()
+	{
+	iPointerCursor=RWsPointerCursor(iWs);
+	TInt err=iPointerCursor.Construct(0);
+	if (err==KErrNone)
+		{
+		TSpriteMember sprite;
+		sprite.iBitmap=iBitmap;
+		sprite.iMaskBitmap=iMask;
+		sprite.iInvertMask=EFalse;
+		sprite.iDrawMode=CGraphicsContext::EDrawModePEN;
+		sprite.iOffset=TPoint(0,0);
+		sprite.iInterval=TTimeIntervalMicroSeconds32(100000);
+		if ((err=iPointerCursor.AppendMember(sprite))==KErrNone)
+			if ((err=iPointerCursor.Activate())==KErrNone)
+				{
+				sprite.iBitmap=iBitmap2;		// Bigger bitmap to force resize of bitmap
+				sprite.iMaskBitmap=iMask2;
+				if ((err=iPointerCursor.AppendMember(sprite))==KErrNone)
+					err=iPointerCursor.UpdateMember(1,sprite);
+				}
+		}
+	return(err);
+	}
+
+void COomPointerCursor::ClearUpL()
+	{
+	iPointerCursor.Close();
+	}
+
+//
+
+COomGc::COomGc(CTOom *aTest) : COomSetup(aTest)
+	{}
+
+COomGc::~COomGc()
+	{
+	delete iScrDev;
+	}
+
+TOomTestName COomGc::TestName()
+	{
+	return(_L("Graphic Context"));
+	}
+
+void COomGc::ConstructL()
+	{
+	COomSetup::ConstructL();
+	iScrDev=new(ELeave) CWsScreenDevice(iWs);
+	User::LeaveIfError(iScrDev->Construct(iTest->ScreenNumber()));
+	}
+
+/** Creates a graphical context for a previously created screen device.
+*/
+TInt COomGc::Fail()
+	{
+	TRAPD(err,iFailGc=new(ELeave) CWindowGc(iScrDev));
+	if (err!=KErrNone)
+		return(err);
+	return(iFailGc->Construct());
+	}
+
+void COomGc::ClearUpL()
+	{
+	delete iFailGc;
+	iFailGc=NULL;
+	}
+
+//
+
+COomPolygon::COomPolygon(CTOom *aTest) : COomSetup(aTest), iPnts(5)
+	{}
+
+COomPolygon::~COomPolygon()
+	{
+	delete iGc;
+	delete iScrDev;
+	iWin.Close();
+	}
+
+TOomTestName COomPolygon::TestName()
+	{
+	return(_L("Polygon"));
+	}
+
+void COomPolygon::ConstructL()
+	{
+	COomSetup::ConstructL();
+	iScrDev=new(ELeave) CWsScreenDevice(iWs);
+	User::LeaveIfError(iScrDev->Construct(iTest->ScreenNumber()));
+	User::LeaveIfError(iScrDev->CreateContext(iGc));
+	iWin=RBackedUpWindow(iWs);
+	User::LeaveIfError(iWin.Construct(iWinGroup,EGray16,33));
+	User::LeaveIfError(iWin.SetSizeErr(TSize(40,40)));
+	iWin.Activate();
+	TInt index;
+	for(index=0;index<20;index+=2)
+		iPnts.AppendL(TPoint(20+index,index));
+	for(index=0;index<20;index+=2)
+		iPnts.AppendL(TPoint(40-index,20+index));
+	for(index=0;index<20;index+=2)
+		iPnts.AppendL(TPoint(20-index,40-index));
+	for(index=0;index<20;index+=2)
+		iPnts.AppendL(TPoint(index,20-index));
+	}
+
+/** Draws a polygon.
+*/
+TInt COomPolygon::Fail()
+	{
+	iGc->Activate(iWin);
+	iGc->Clear();
+	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+	iGc->SetBrushColor(TRgb::Gray4(2));
+	iGc->SetPenColor(TRgb::Gray4(0));
+	TInt err=iGc->DrawPolygon(&iPnts,CGraphicsContext::EAlternate);
+	if (err!=KErrNone)
+		return(err);
+	err=iGc->DrawPolygon(&iPnts,CGraphicsContext::EWinding);
+	if (err!=KErrNone)
+		return(err);
+	return(KErrNone);
+	}
+
+void COomPolygon::ClearUpL()
+	{
+	iGc->Deactivate();
+	}
+
+//
+
+COomScreenDevice::COomScreenDevice(CTOom *aTest) : COomSetup(aTest)
+	{}
+
+TOomTestName COomScreenDevice::TestName()
+	{
+	return(_L("Screen device"));
+	}
+
+/** Creates a screen device handle.
+*/
+TInt COomScreenDevice::Fail()
+	{
+	TRAPD(err,iScrDev=new(ELeave) CWsScreenDevice(iWs));
+	if (err!=KErrNone)
+		return(err);
+	return(iScrDev->Construct(iTest->ScreenNumber()));
+	}
+
+void COomScreenDevice::ClearUpL()
+	{
+	delete iScrDev;
+	iScrDev=NULL;
+	}
+
+//
+
+COomCustomTextCursor::COomCustomTextCursor(CTOom *aTest) : COomSetup(aTest)
+	{}
+
+COomCustomTextCursor::~COomCustomTextCursor()
+	{
+	delete iMemberArray;
+	delete iBitmap;
+	}
+
+TOomTestName COomCustomTextCursor::TestName()
+	{
+	return(_L("Custom Text Cursor"));
+	}
+
+void COomCustomTextCursor::ConstructL()
+	{
+	COomSetup::ConstructL();
+
+	iBitmap = new(ELeave) CFbsBitmap;
+	User::LeaveIfError(iBitmap->Load(TEST_BITMAP_NAME, EMbmWsautotestBmp1));
+
+	TSpriteMember member;
+	member.iMaskBitmap=NULL;
+	member.iInvertMask=EFalse;
+	member.iDrawMode=CGraphicsContext::EDrawModePEN;
+	member.iOffset=TPoint();
+	member.iInterval=TTimeIntervalMicroSeconds32(0);
+	member.iBitmap = iBitmap;
+
+	iMemberArray = new(ELeave) CArrayFixFlat<TSpriteMember>(1);
+	iMemberArray->AppendL(member);
+	}
+
+/** Adds a custom text cursor to the server's list of cursors.
+*/
+TInt COomCustomTextCursor::Fail()
+	{
+	TInt err = TheClient->iWs.SetCustomTextCursor(0x98765432, iMemberArray->Array(), 0, RWsSession::ECustomTextCursorAlignTop);
+	if (err == KErrAlreadyExists)
+		return KErrNone;
+	else
+		return err;
+	}
+
+void COomCustomTextCursor::ClearUpL()
+	{
+	}
+
+COomTranspWindow::COomTranspWindow(CTOom *aTest) : COomSetup(aTest)
+	{}
+
+COomTranspWindow::~COomTranspWindow()
+	{
+	delete iBackgroundWin;
+	delete iFirst;
+	delete iSecond;
+	
+	delete iFbsBitmap;
+	delete iWsBitmap;
+	delete iFbsBitmapDevice; 
+	delete iFbsBitmapGc;
+	delete iWsBitmapDevice; 
+	delete iWsBitmapGc;				
+	}
+
+TOomTestName COomTranspWindow::TestName()
+	{
+	return(_L("Transparent Window"));
+	}
+
+void COomTranspWindow::ConstructL()
+	{
+	COomSetup::ConstructL();
+	
+	iTransparencyEnabled = (TransparencySupportedL() == KErrNone);
+	if(!iTransparencyEnabled)
+		return;
+
+	iFbsBitmap = new (ELeave) CFbsBitmap;
+
+	// Do the creation 
+	const TSize KSizeForBitmap(10,10);
+	iFbsBitmap->Create(KSizeForBitmap,EGray256);
+	
+	// Fill the bitmap with a colour		
+	iFbsBitmapDevice=CFbsBitmapDevice::NewL(iFbsBitmap);
+		
+	iFbsBitmapDevice->CreateContext(iFbsBitmapGc);
+	
+	iFbsBitmapGc->SetPenStyle(CGraphicsContext::ENullPen);
+	iFbsBitmapGc->SetBrushStyle(CGraphicsContext::ESolidBrush);	
+	iFbsBitmapGc->SetBrushColor(128);
+	iFbsBitmapGc->DrawRect(TRect(KSizeForBitmap));
+	
+	// Create a CWsBitmap, and fill it with a colour	
+	iWsBitmap = new (ELeave) CWsBitmap(TheClient->iWs);
+	
+	// Do the creation 
+	iWsBitmap->Create(KSizeForBitmap,EGray256);	
+		
+	// Fill the bitmap with a colour		
+	iWsBitmapDevice=CFbsBitmapDevice::NewL(iWsBitmap);	
+			
+	iWsBitmapDevice->CreateContext(iWsBitmapGc);		
+	iWsBitmapGc->SetPenStyle(CGraphicsContext::ENullPen);
+	iWsBitmapGc->SetBrushStyle(CGraphicsContext::ESolidBrush);	
+	iWsBitmapGc->SetBrushColor(128);
+	iWsBitmapGc->DrawRect(TRect(KSizeForBitmap));				
+	}
+	
+
+/** Does nothing if transparency is not enabled. Creates a blank window with 
+* two transparent child-windows. Tests setting the transparency via a factor, CFbsBitmap
+* or a CWsBitmap, and changing from one to the other.
+* Changes child-windows' sizes and toggles their visibility.
+*/
+TInt COomTranspWindow::Fail()
+	{
+	if(!iTransparencyEnabled)
+		return KErrNone;
+	TSize scrSize(TheClient->iScreen->SizeInPixels());
+	TRAPD(res, iBackgroundWin = new (ELeave) CBlankWindow(TRgb(0,0,238)));
+	if(res != KErrNone)
+		{
+		return res;	
+		}
+
+	TDisplayMode mode=EColor256;
+	TRAP(res, iBackgroundWin->SetUpL(TPoint(50,50),scrSize-TSize(100,100),TheClient->iGroup,*TheClient->iGc,&mode));
+	if(res != KErrNone)
+		{
+		return res;
+		}
+
+	TheClient->Flush();
+	TheClient->WaitForRedrawsToFinish();
+
+	iBackgroundWin->Win()->SetBackgroundColor(TRgb(51,204,51));
+	iBackgroundWin->Invalidate();
+
+	TheClient->Flush();
+	TheClient->WaitForRedrawsToFinish();
+
+	TRect	thePos1(20, 20, 60, 60);
+	TRect	thePos2(100, 40, 160, 80);
+	TRAP(res, iFirst = CTransWindow::NewL(iBackgroundWin, TRgb(255,0,0,128),&mode));
+	if(res != KErrNone)
+		{
+		return res;
+		}
+
+	TRAP(res, iSecond = CTransWindow::NewL(iBackgroundWin, TRgb(255,0,0,128),&mode));
+	if(res != KErrNone)
+		{
+		return res;
+		}
+
+	TRAP(res, iFirst->SetExtL(thePos1.iTl,thePos1.Size()));
+	if(res != KErrNone)
+		{
+		return res;
+		}
+
+	TRAP(res, iSecond->SetExtL(thePos2.iTl,thePos2.Size()));
+	if(res != KErrNone)
+		{
+		return res;
+		}
+
+	res=SetTransparencyTesting();
+	if(res != KErrNone)
+		{
+		return res;
+		}
+
+	TheClient->Flush();
+	//TheClient->WaitForRedrawsToFinish();
+
+	iFirst->Activate();
+	iFirst->AssignGC(*TheClient->iGc);
+
+	iSecond->Activate();
+	iSecond->AssignGC(*TheClient->iGc);
+
+	iFirst->Win()->SetBackgroundColor(TRgb(0, 0, 255));
+	iSecond->Win()->SetBackgroundColor(TRgb(0, 0, 255));
+	iFirst->Invalidate();
+	iSecond->Invalidate();
+	
+	iFirst->AdjustSize(150,10, 0);
+	iSecond->AdjustSize(150,10, 0);
+
+	TheClient->Flush();
+	TheClient->WaitForRedrawsToFinish();
+
+	iFirst->ToggleVisibility();
+	iSecond->ToggleVisibility();
+
+	TheClient->Flush();
+	TheClient->WaitForRedrawsToFinish();
+	
+	iFirst->AdjustSize(200,10, 0);
+	iSecond->AdjustSize(200,10, 0);
+
+	iFirst->ToggleVisibility();
+	iSecond->ToggleVisibility();
+
+	TheClient->Flush();
+	TheClient->WaitForRedrawsToFinish();
+
+	return KErrNone;
+	}
+
+
+// This function tests setting the transparency via a factor, CFbsBitmap
+// or a CWsBitmap, and changing from one to the other.
+TInt COomTranspWindow::SetTransparencyTesting()
+	{
+	TInt res;	
+	TLogMessageText buf;
+		
+	// Need all nine transitions, from the 3 ways to the same 3 ways.
+	// The ways are Factor, CWsBitmap, CFbsBitmap
+	const TRgb KTransparencyFactor(128,128,128);
+	res=iFirst->Win()->SetTransparencyFactor(KTransparencyFactor);
+	if (res!=KErrNone)
+		{
+		buf=_L("test failure!! with SetTransparencyFactor -1");
+		TheClient->LogMessage(buf);
+		return res;
+		}
+			
+	res=iFirst->Win()->SetTransparencyBitmap(*iFbsBitmap);
+	if (res!=KErrNone)
+		{
+		buf=_L("test failure!! with SetTransparencyBitmap - fbs -2");
+		TheClient->LogMessage(buf);
+		return res;
+		}			
+		
+	res=iFirst->Win()->SetTransparencyWsBitmap(*iWsBitmap);
+	if (res!=KErrNone)
+		{
+		buf=_L("test failure!! with SetTransparencyBitmap - Ws -3");
+		TheClient->LogMessage(buf);
+		return res;
+		}
+				
+	res=iFirst->Win()->SetTransparencyFactor(KTransparencyFactor);
+	if (res!=KErrNone)
+		{
+		buf=_L("test failure!! with SetTransparencyBitmap - fbs -4");
+		TheClient->LogMessage(buf);
+		return res;
+		}	
+	res=iFirst->Win()->SetTransparencyWsBitmap(*iWsBitmap);
+	if (res!=KErrNone)
+		{
+		buf=_L("test failure!! with SetTransparencyBitmap - Ws -5");
+		TheClient->LogMessage(buf);
+		return res;
+		}
+	res=iFirst->Win()->SetTransparencyWsBitmap(*iWsBitmap);
+	if (res!=KErrNone)
+		{
+		buf=_L("test failure!! with SetTransparencyBitmap - Ws -6");
+		TheClient->LogMessage(buf);
+		return res;
+		}			
+		
+	res=iFirst->Win()->SetTransparencyBitmap(*iFbsBitmap);
+	if (res!=KErrNone)
+		{
+		buf=_L("test failure!! with SetTransparencyBitmap - fbs -7");
+		TheClient->LogMessage(buf);
+		return res;
+		}	
+		
+	res=iFirst->Win()->SetTransparencyBitmap(*iFbsBitmap);
+	if (res!=KErrNone)
+		{
+		buf=_L("test failure!! with SetTransparencyBitmap - fbs -8");
+		TheClient->LogMessage(buf);
+		return res;
+		}
+		
+	res=iFirst->Win()->SetTransparencyFactor(KTransparencyFactor);
+	if (res!=KErrNone)
+		{
+		buf=_L("test failure!! with SetTransparencyFactor -9");
+		TheClient->LogMessage(buf);
+		return res;
+		}				
+		
+	res=iFirst->Win()->SetTransparencyFactor(KTransparencyFactor);
+	if (res!=KErrNone)
+		{
+		buf=_L("test failure!! with SetTransparencyFactor -10");
+		TheClient->LogMessage(buf);
+		return res;
+		}
+					
+	return res;
+	}	
+
+void COomTranspWindow::ClearUpL()
+	{
+	delete iFirst;
+	iFirst = NULL;
+	delete iSecond;
+	iSecond = NULL;
+	delete iBackgroundWin;
+	iBackgroundWin = NULL;
+	}
+
+//
+
+CWindowWithOneLine* CWindowWithOneLine::NewL(CTWinBase& aParent, const TRect& aExtent)
+	{
+	CWindowWithOneLine* self = new(ELeave) CWindowWithOneLine;
+	CleanupStack::PushL(self);
+	self->ConstructL(aParent);
+	const TSize screenSize(TheClient->iScreen->SizeInPixels());	
+	self->SetExtL(aExtent.iTl, aExtent.Size());
+	self->AssignGC(*TheClient->iGc);
+	self->Activate();
+	self->DrawNow();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+void CWindowWithOneLine::Draw()
+	{
+	iGc->DrawLine(TPoint(0,0), TPoint(Size().iWidth, Size().iHeight));
+	}
+
+//
+
+COomObscuredWindow::COomObscuredWindow(CTOom *aTest) : COomSetup(aTest)
+	{}
+
+TOomTestName COomObscuredWindow::TestName()
+	{
+	return(_L("Obscured window"));
+	}
+
+TInt COomObscuredWindow::Fail()
+	{
+	TRAPD(err, DoFailL());
+	return err;
+	}
+
+	
+void COomObscuredWindow::DoFailL()
+	{
+#ifdef __WINS__
+	RDebug::Print(_L("COomObscuredWindow::DoFailL - enter"));
+#endif
+	const TRect extent(20, 20, 100, 100);
+	CBlankWindow* backgroundWindow = new(ELeave) CBlankWindow(TRgb(12, 23, 34));
+	CleanupStack::PushL(backgroundWindow);
+	TDisplayMode mode = EColor16MAP;
+	backgroundWindow->SetUpL(extent.iTl, extent.Size(), TheClient->iGroup, *TheClient->iGc, &mode);
+	
+	CWindowWithOneLine* window = CWindowWithOneLine::NewL(*backgroundWindow, extent);
+	CleanupStack::PushL(window);
+#ifdef __WINS__
+	RDebug::Print(_L("COomObscuredWindow - WaitForRedrawsToFinish - 1"));
+#endif
+	TheClient->WaitForRedrawsToFinish();
+	
+	CBlankWindow* obscuringWindow = new(ELeave) CBlankWindow(TRgb(255, 0, 0));
+	CleanupStack::PushL(obscuringWindow);
+	obscuringWindow->SetUpL(extent.iTl, extent.Size(), backgroundWindow, *TheClient->iGc, &mode);
+
+	TheClient->Flush();
+#ifdef __WINS__
+    RDebug::Print(_L("COomObscuredWindow - WaitForRedrawsToFinish - 2"));
+#endif
+	TheClient->WaitForRedrawsToFinish();
+
+	window->Invalidate();
+
+	for(TInt i = 0; i < 50; i++)
+		{
+		RWindow anotherWin(iWs);
+		User::LeaveIfError(anotherWin.Construct(iWinGroup, 11));
+		anotherWin.Close();
+		
+		if(i % 4)
+			window->Invalidate();
+
+		TheClient->Flush();
+#ifdef __WINS__
+	    RDebug::Print(_L("COomObscuredWindow - WaitForRedrawsToFinish - 3 - %d"), i);
+#endif
+	    TheClient->WaitForRedrawsToFinish();
+		}
+
+	TheClient->Flush();
+#ifdef __WINS__
+    RDebug::Print(_L("COomObscuredWindow - WaitForRedrawsToFinish - 4"));
+#endif
+	TheClient->WaitForRedrawsToFinish();
+
+	CleanupStack::PopAndDestroy(obscuringWindow);
+	CleanupStack::PopAndDestroy(window);
+	CleanupStack::PopAndDestroy(backgroundWindow);
+#ifdef __WINS__
+    RDebug::Print(_L("COomObscuredWindow::DoFailL - exit"));
+#endif
+	}
+
+void COomObscuredWindow::ClearUpL()
+	{
+	}	
+
+//
+
+CTOom::CTOom(CTestStep* aStep) : CTWsGraphicsBase(aStep)
+	{
+	iState = 0;
+	}
+	
+const TDesC& CTOom::TestName() const
+	{
+	_LIT(KTestName,"CTOom");
+	return(KTestName());
+	}
+	
+void CTOom::DoOomTestL(COomFailBase *aOomTest)
+	{
+	//TLogMessageText buf;
+	TEST(aOomTest!=NULL);
+	if (aOomTest==NULL)
+		INFO_PRINTF1(_L("aOomTest - Expected: Not Null, Actual: NULL"));			
+
+	TRAPD(ret1,aOomTest->ConstructL());
+	TEST(ret1==KErrNone);
+	if (ret1!=KErrNone)
+		INFO_PRINTF3(_L("aOomTest->ConstructL() return value - Expected: %d, Actual: %d"), KErrNone, ret1);			
+
+	aOomTest->Flush();
+	__UHEAP_MARK;
+//	TInt oldCount=TheClient->iWs.HeapCount();
+	for(TInt mode=0;mode<3;mode++)
+		{
+		/*buf.Format(_L("OOMTest[%d] Mode=%d"),iState,mode),
+		TheClient->LogMessage(buf);*/
+		TInt successCount=0;
+		for(TInt count=1;;count++)
+			{
+			TInt ret;
+			aOomTest->PreFail();
+			if (mode==0)
+				TheClient->iWs.HeapSetFail(RHeap::EDeterministic,count);
+			else if (mode==1)
+				TheClient->iWs.HeapSetBurstFail(RHeap::EBurstFailNext, count, KMaxTUint16);
+			else if (mode==3)
+				{
+				__UHEAP_SETFAIL(RHeap::EDeterministic,count);	//Leavescan will complain about EFailNext, although it isn't a leaving function
+				}
+			ret=aOomTest->Fail();
+			if (mode==0)
+				TheClient->iWs.HeapSetFail(RHeap::ENone,0);
+			else if (mode==1)
+				TheClient->iWs.HeapSetBurstFail(RHeap::ENone, 0, 0);
+			else if (mode==2)
+				{
+				__UHEAP_RESET;
+				}
+			aOomTest->ClearUpL();  //In just 1 case this could leave...
+			aOomTest->Flush();
+			if (ret==KErrNone)
+				{
+				if (successCount==10)
+					break;
+				successCount++;
+				}
+			else
+				{
+				/*if (successCount>0)
+					{
+					buf.Format(_L("[%d,%d] Count=%d, MaxSuccess=%d"),iState,mode,count,successCount);
+					TheClient->LogMessage(buf);
+					}*/
+				successCount=0;
+				/*if (ret!=KErrNoMemory)
+					{
+					buf.Format(_L("[%d,%d] Fail, Count=%d, Error=%d"),iState,mode,count,ret);
+					TheClient->LogMessage(buf);
+					}*/
+				TEST(ret==KErrNoMemory);
+				if (ret!=KErrNoMemory)
+					INFO_PRINTF3(_L("aOomTest->Fail() return value - Expected: %d, Actual: %d"), KErrNoMemory, ret);			
+
+				}
+			}
+		/*buf.Format(_L("[%d,%d] LastCount=%d"),iState,mode,count),
+		TheClient->LogMessage(buf);*/
+		}
+//	TEST(oldCount>=TheClient->iWs.HeapCount());
+	__UHEAP_MARKEND;
+	delete aOomTest;
+	/*buf.Format(_L("OOMTest[%d] Finished"),iState);
+	TheClient->LogMessage(buf);*/
+	}
+
+void CTOom::ConstructL()
+	{
+	iShieldWin=RBlankWindow(TheClient->iWs);
+	User::LeaveIfError(iShieldWin.Construct(*(TheClient->iGroup->GroupWin()),1));
+//	iShieldWin.SetOrdinalPosition(0,-1);
+	iShieldWin.Activate();
+	}
+
+CTOom::~CTOom()
+	{
+	iShieldWin.Close();
+	}
+
+/**
+@SYMTestCaseID		GRAPHICS-WSERV-0124
+
+@SYMDEF             DEF081259
+
+@SYMTestCaseDesc    Out of memory tests
+
+@SYMTestPriority    High
+
+@SYMTestStatus      Implemented
+
+@SYMTestActions     Uses deterministic heap failure mode to test WSERV classes against out-of-memory errors.
+					Sets and unsets deterministic mode using both RWsSession.HeapSetFail() methods and
+					__UHEAP_SETFAIL/__UHEAP_RESET macros (doing this both client and WSERV threads are tested). 
+					On each step the test creates a failure object and repeatedly asks it to do some work (calling Fail() method).
+					A failure object is an object which encapsulates some allocation functionality inside it's Fail() method.
+					The test is performed for 23 different failure objects that do the following:
+						1. Creates a wserv session, connects and creates CWsScreenDevice object.
+						2. Creates a RWindowGroup object.
+						3. Creates a RWindow object.
+						4. Creates a RBackedUpWindow object.
+						5. Sets the size of previously created backed-up window.
+						6. Creates a RBlankWindow object.
+						7. Allocates a buffer for storing pointer movements for a previously created backed-up window.
+						8. Adds a priority key for a previously created window group.
+						9. Requests a capture keys for a previously created window group.
+						10. Requests the capture of key-up and key-down events for a previously created window group.
+						11. Sets hot key for the session.
+						12. Sets the window group's name.
+						13. Sends a message to another window group.
+						14. Fetches a message.
+						15. Enables window group change events and modifier change events.
+						16. Copies screen to bitmap.
+						17. Creates a sprite.
+						18. Creates a pointer cursor.
+						19. Creates a graphical context for a previously created screen device.
+						20. Draws a polygon.
+						21. Creates a screen device handle.
+						22. Adds a custom text cursor to the server's list of cursors.
+						23. Does nothing if transparency is not enabled. Creates a blank window with 
+							two transparent child-windows. Tests setting the transparency via a factor, CFbsBitmap
+							or a CWsBitmap, and changing from one to the other.
+							Changes child-windows' sizes and toggles their visibility.
+					
+
+@SYMTestExpectedResults The test checks that the creation failure objects doesn't fail and their's work either causes no errors or causes KErrNoMemory error.
+*/
+void CTOom::RunTestCaseL(TInt /*aCurTestCase*/) 
+	{
+	((CTOomStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0124"));
+	if (iState==0)
+		{
+		// commented by Anton Golovko, 01.03.2006 while converting to TEF
+		// the code below prevented the test to do anything.
+//		if (iTest->IsFullRomL()) 
+//			{
+//			TestComplete();
+//			return;
+//			}
+		iOldCount=TheClient->iWs.HeapCount();
+		}
+	else if (iState==sizeof(CreateOomFailTest)/sizeof(CreateOomFailTest[0]))
+		{
+		iTest->CloseAllPanicWindows();
+		TInt heapCount=TheClient->iWs.HeapCount();
+		if (heapCount>iOldCount)
+			{
+			TEST(iOldCount>=heapCount-184);		//For some uninvestigated reason 184 object get allocated on the server side, partly because of INFO_PRINTF1
+			if (iOldCount<heapCount-184)
+					INFO_PRINTF3(_L("iOldCount>=heapCount-174 - Expected: %d, Actual: %d"), heapCount-184, iOldCount);			
+
+			}
+		((CTOomStep*)iStep)->CloseTMSGraphicsStep();
+		TestComplete();
+		return;
+		}
+	DoOomTestL(CreateOomFailTest[iState++](this));
+	((CTOomStep*)iStep)->RecordTestResultL();
+	}
+	
+	
+	
+	
+__WS_CONSTRUCT_STEP__(Oom)
+