--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/test/tauto/TOOM.CPP Tue Jun 22 15:21:29 2010 +0300
@@ -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)
+