--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/test/tauto/TSPRITE.CPP	Wed Jun 23 19:41:15 2010 +0300
@@ -0,0 +1,996 @@
+// 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:
+//
+
+/**
+ @file
+ @test
+ @internalComponent - Internal Symbian test code
+*/
+
+#include "TSPRITE.H"
+
+CTTSprite::CTTSprite(CTestStep* aStep):
+	CTWsGraphicsBase(aStep)
+	{
+	INFO_PRINTF1(_L("Testing TSprite functions"));
+	}
+
+void CTTSprite::SetUpMember(TSpriteMember &aMember)
+	{
+	aMember.iMaskBitmap=NULL;
+	aMember.iInvertMask=EFalse;
+	aMember.iDrawMode=CGraphicsContext::EDrawModePEN;
+	aMember.iOffset=TPoint();
+	aMember.iInterval=TTimeIntervalMicroSeconds32(0);
+	aMember.iBitmap=&iBitmap;
+	}
+
+void CTTSprite::SetUpPointerCursorL(RWsPointerCursor &aCursor, RWsSession &aSession)
+	{
+	aCursor=RWsPointerCursor(aSession);
+	TSpriteMember member;
+	SetUpMember(member);
+	User::LeaveIfError(aCursor.Construct(0));
+	User::LeaveIfError(aCursor.AppendMember(member));
+	User::LeaveIfError(aCursor.Activate());
+	}
+
+void CTTSprite::SetUpSpriteL(RWsSprite &aSprite, RWsSession &aSession, RWindowTreeNode &aWindow,TInt aFlags/*=0*/)
+	{
+	aSprite=RWsSprite(aSession);
+	User::LeaveIfError(aSprite.Construct(aWindow,TPoint(),aFlags));
+	TSpriteMember member;
+	SetUpMember(member);
+	User::LeaveIfError(aSprite.AppendMember(member));
+	User::LeaveIfError(aSprite.Activate());
+	}
+
+void CTTSprite::ConstructL()
+	{
+  	User::LeaveIfError(iBitmap.Load(TEST_BITMAP_NAME,0));
+	}
+	
+CTTSprite::~CTTSprite()
+	{
+	}
+
+/**
+@SYMTestCaseID		GRAPHICS-WSERV-0018
+
+@SYMDEF  			DEF081259
+
+@SYMTestCaseDesc    General cursor tests involving a sprite
+
+@SYMTestPriority    High
+
+@SYMTestStatus      Implemented
+
+@SYMTestActions     Carries out cursor and window tests before updating
+					a cursor's member with a sprite
+
+@SYMTestExpectedResults When the cursor member is update returns KErrArgument
+*/
+
+void CTTSprite::GeneralTestsL()
+	{
+//
+// Close cursor while still active on a window
+//
+	
+	RWindow win(TheClient->iWs);
+	win.Construct(*TheClient->iGroup->GroupWin(),1);
+	win.Activate();
+	SetUpPointerCursorL(iCursor1,TheClient->iWs);
+	win.SetCustomPointerCursor(iCursor1);
+	iCursor1.Close();
+//
+// Close window while cursor active on it
+//
+	SetUpPointerCursorL(iCursor1,TheClient->iWs);
+	win.SetCustomPointerCursor(iCursor1);
+	win.Close();
+	iCursor1.Close();
+	
+//
+// Close session with:
+// An open cursor active on a window & A closed cursor active on another window
+//
+	RWsSession ws;
+	User::LeaveIfError(ws.Connect());
+	// use correct screen
+	//
+	ws.SetFocusScreen(iTest->iScreenNumber);
+	CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws);
+	CleanupStack::PushL(screen);
+	User::LeaveIfError(screen->Construct(0));
+
+	RWindowGroup group(ws);
+	User::LeaveIfError(group.Construct(123));
+	group.EnableReceiptOfFocus(EFalse);	// Stop auto group switching on close
+	RWindow win2(ws);
+	User::LeaveIfError(win2.Construct(group, 1));
+	win2.Activate();
+	RWindow win3(ws);
+	User::LeaveIfError(win3.Construct(group, 2));
+	win3.Activate();
+//
+	SetUpPointerCursorL(iCursor1,ws);
+	SetUpPointerCursorL(iCursor2,ws);
+	win2.SetCustomPointerCursor(iCursor1);
+	win3.SetCustomPointerCursor(iCursor2);
+//
+	TSpriteMember member;
+	member.iBitmap=member.iMaskBitmap=NULL;
+	TInt err = iCursor1.UpdateMember(9999,member);
+	TEST(err==KErrArgument);
+	if (err!=KErrArgument)
+		INFO_PRINTF3(_L("iCursor1.UpdateMember(9999,member) return value  - Expected: %d, Actual: %d"), KErrArgument, err);
+
+	iCursor1.Close();
+
+	CleanupStack::PopAndDestroy(screen);	
+	ws.Close();
+	}
+
+/**
+@SYMTestCaseID		GRAPHICS-WSERV-0019
+
+@SYMDEF  			DEF081259
+
+@SYMTestCaseDesc    Construct a sprite in a group window
+
+@SYMTestPriority    High
+
+@SYMTestStatus      Implemented
+
+@SYMTestActions     Creates a sprite in a group window
+
+@SYMTestExpectedResults The sprite is created without error
+*/
+void CTTSprite::GroupWindowSpritesL()
+	{
+	RWsSprite sprite1;
+	RWsSprite sprite2;
+	SetUpSpriteL(sprite1,TheClient->iWs,*TheClient->iGroup->GroupWin());
+	SetUpSpriteL(sprite2,TheClient->iWs,*TheClient->iGroup->GroupWin());
+	TheClient->iWs.Flush();
+	sprite2.Close();
+	sprite1.Close();
+	}
+
+/**
+@SYMTestCaseID		GRAPHICS-WSERV-0020
+
+@SYMDEF  			DEF081259
+
+@SYMTestCaseDesc    Constructs a number of different sprites in different windows
+
+@SYMTestPriority    High
+
+@SYMTestStatus      Implemented
+
+@SYMTestActions     Creates many sprites in three different windows and the checks
+					the sprites can be manipulated
+
+@SYMTestExpectedResults The sprite are created and manipulated without error
+*/
+#define NUM_SPRITES 8
+void CTTSprite::LotsSpritesL()
+	{
+	CTBlankWindow* win=new(ELeave) CTBlankWindow();
+	CTBlankWindow* win2=new(ELeave) CTBlankWindow();
+	TSize size(100,120);
+	win->ConstructL(*TheClient->iGroup);
+	win2->ConstructL(*win);
+	win2->SetExt(TPoint(100,100),size);
+	win2->SetColor(TRgb::Gray4(2));
+	RWindowBase window=*win->BaseWin();
+	RWindowBase window2=*win2->BaseWin();
+	window.Activate();
+	window2.Activate();
+	RWsSprite sprite[NUM_SPRITES];
+	TInt ii;
+	//TheClient->iWs.SetAutoFlush(ETrue);
+	for (ii=0;ii<NUM_SPRITES;ii++)
+		SetUpSpriteL(sprite[ii],TheClient->iWs,window);
+	sprite[4].Close();
+	sprite[2].SetPosition(TPoint(20,20));
+	sprite[0].Close();
+	win2->SetExt(TPoint(80,100),size);
+	sprite[6].SetPosition(TPoint(60,120));
+	sprite[7].Close();
+	sprite[5].SetPosition(TPoint(100,120));
+	sprite[3].Close();
+	SetUpSpriteL(sprite[7],TheClient->iWs,window);
+	sprite[7].SetPosition(TPoint(80,150));
+	sprite[1].Close();
+	win2->SetExt(TPoint(60,110),size);
+	sprite[5].SetPosition(TPoint(50,40));
+	sprite[7].Close();
+	SetUpSpriteL(sprite[0],TheClient->iWs,window);
+	sprite[0].SetPosition(TPoint(55,65));
+	sprite[6].Close();
+	win2->SetExt(TPoint(40,90),size);
+	sprite[2].SetPosition(TPoint(80,45));
+	sprite[5].Close();
+	sprite[0].SetPosition(TPoint(90,60));
+	sprite[2].Close();
+	SetUpSpriteL(sprite[2],TheClient->iWs,window);
+	sprite[2].SetPosition(TPoint(70,80));
+	sprite[0].Close();
+	win2->SetExt(TPoint(20,80),size);
+	sprite[2].SetPosition(TPoint(600,200));
+	sprite[2].Close();
+	SetUpSpriteL(sprite[0],TheClient->iWs,window2,ESpriteFlash);
+	sprite[0].SetPosition(TPoint(0,25));
+	SetUpSpriteL(sprite[1],TheClient->iWs,window2,ESpriteFlash);
+	SetUpSpriteL(sprite[2],TheClient->iWs,window2,ESpriteFlash);
+	sprite[2].SetPosition(TPoint(25,0));
+	win2->SetExt(TPoint(40,70),size);
+	CTBlankWindow* win3=new(ELeave) CTBlankWindow();
+	win3->ConstructL(*TheClient->iGroup);
+	win3->SetExt(TPoint(30,60),TSize(30,30));
+	win3->SetColor(TRgb::Gray4(1));
+	win3->BaseWin()->SetShadowHeight(10);
+	win3->BaseWin()->Activate();
+	User::After(1000000);		//1 sec so sprites has time to flash
+	delete win2;
+	delete win;
+	delete win3;
+	sprite[0].Close();
+	sprite[1].Close();
+	sprite[2].Close();
+	}
+
+/**
+@SYMTestCaseID		GRAPHICS-WSERV-0021
+
+@SYMDEF  			DEF081259
+
+@SYMTestCaseDesc    General PointerCursor Tests
+
+@SYMTestPriority    High
+
+@SYMTestStatus      Implemented
+
+@SYMTestActions     Exercise the different pointercursor methods of a Window Server Session
+
+@SYMTestExpectedResults The methods are called without error
+*/
+void CTTSprite::GeneralPointerCursor()
+	{
+	if (!TestBase()->ConfigurationSupportsPointerEventTesting())
+	    {
+	    INFO_PRINTF1(_L("Test skipped because config does not support pointer event testing"));
+	    return;
+	    }
+	TInt currentSMode=TheClient->iScreen->CurrentScreenMode();
+	TInt altSMode=-1;
+	if (TheClient->iScreen->NumScreenModes()>1)
+		altSMode=(currentSMode==1?0:1);
+	RWsSession &ws=TheClient->iWs;
+	TRect rect=ws.PointerCursorArea();
+	TRect testRect1(TPoint(rect.iBr.iX/4,rect.iBr.iY/4),TSize(rect.Width()/2,rect.Height()/2));
+	TRect testRect2(TPoint(rect.iBr.iX/3,rect.iBr.iY/3),TSize(2*rect.Width()/3,2*rect.Height()/3));
+	ws.SetPointerCursorArea(testRect1);
+	TEST(ws.PointerCursorArea()==testRect1);
+	TEST(ws.PointerCursorArea(currentSMode)==testRect1);
+	ws.SetPointerCursorArea(currentSMode,testRect2);
+	TEST(ws.PointerCursorArea()==testRect2);
+	TEST(ws.PointerCursorArea(currentSMode)==testRect2);
+	ws.SetPointerCursorArea(rect);
+	TEST(ws.PointerCursorArea()==rect);
+	
+	if (altSMode>=0)
+		{
+		rect=ws.PointerCursorArea(altSMode);
+		testRect1.iTl.iX=rect.iBr.iX/4;
+		testRect1.iTl.iY=rect.iBr.iY/4;
+		testRect1.SetWidth(rect.Width()/2);
+		testRect1.SetHeight(rect.Height()/2);
+		ws.SetPointerCursorArea(altSMode,testRect1);
+		TEST(ws.PointerCursorArea(altSMode)==testRect1);
+		ws.SetPointerCursorArea(altSMode,rect);
+		TEST(ws.PointerCursorArea(altSMode)==rect);
+		}
+	TPointerCursorMode currentMode=ws.PointerCursorMode();
+	TInt ii;
+	TInt err1;
+	for(ii=EPointerCursorFirstMode;ii<=EPointerCursorLastMode;ii++)
+		{	
+		ws.SetPointerCursorMode(STATIC_CAST(TPointerCursorMode,ii));
+		err1 = ws.PointerCursorMode();
+		TEST(ii==err1);
+		if (ii!=err1)
+			INFO_PRINTF3(_L("ws.PointerCursorMode() return value  - Expected: %d, Actual: %d"), ii, err1);		
+		}
+	ws.SetPointerCursorMode(currentMode);
+	TEST(currentMode==ws.PointerCursorMode());
+	TPoint point1(10,12);
+	TPoint point2(24,20);
+	ws.PointerCursorPosition();
+	ws.SetPointerCursorPosition(point1);
+	TEST(ws.PointerCursorPosition()==point1);
+	ws.SetPointerCursorPosition(point2);
+	TEST(ws.PointerCursorPosition()==point2);
+	}
+
+
+/**
+@SYMTestCaseID      GRAPHICS-WSERV-0498
+
+@SYMDEF             PDEF137614 - Propagation to TB92
+
+@SYMTestCaseDesc    Test activating a pointer cursor
+
+@SYMTestPriority    High
+
+@SYMTestStatus      Implemented
+
+@SYMTestActions     Construct and activate a pointer cursor. 
+                    Check it is visible.
+                    Deactivate it
+                    Check it is removed
+                    
+
+@SYMTestExpectedResults 
+                    The pointer cursor bitmp should be visible when activated and removed when deactivated.
+*/
+
+void CTTSprite::PointerCursorVisibleL()
+    {
+    if (!TestBase()->ConfigurationSupportsPointerEventTesting())
+        {
+        INFO_PRINTF1(_L("Test skipped because config does not support pointer event testing"));
+        return;
+        }
+    
+    // The pointer events need time to have an affect on the wserv
+    static const TInt eventPropagationDelay = 100 * 1000; // 100 ms
+    
+    TInt screenNumber = TheClient->iScreen->GetScreenNumber();
+    
+    if(screenNumber != 0) // pointer events only supported on emulator screen 0
+        {
+        LOG_MESSAGE(_L("Pointer Cursor Visible only runs on screen 0"));
+        return;
+        }
+    
+    // set up objects used in test
+    // 50x50 red rectangle colour 24
+    CFbsBitmap bitmap;
+    User::LeaveIfError(bitmap.Load(TEST_BITMAP_NAME, 8));
+    
+    TSize bmSize = bitmap.SizeInPixels();
+    TPoint bmSample = TPoint(bmSize.iWidth / 2, bmSize.iHeight / 2);
+    TRgb bmColour;
+    bitmap.GetPixel(bmColour, bmSample);
+    TEST(bmColour == KRgbRed);
+
+    // single window, size of screen
+    RWindow win(TheClient->iWs);
+    User::LeaveIfError(win.Construct(*TheClient->iGroup->GroupWin(),1));
+    win.Activate();
+
+    // setup cursor mode
+    TheClient->iWs.SetPointerCursorMode(EPointerCursorWindow);
+    
+    // setup cursor to contain single 50x50 red bitmap
+    RWsPointerCursor iCursor1 = RWsPointerCursor(TheClient->iWs);
+    TSpriteMember member;
+    SetUpMember(member);
+    member.iBitmap=&bitmap;
+    User::LeaveIfError(iCursor1.Construct(0));
+    User::LeaveIfError(iCursor1.AppendMember(member));
+    User::LeaveIfError(iCursor1.Activate());
+    win.SetCustomPointerCursor(iCursor1);
+    iCursor1.UpdateMember(0);
+
+    // draw a green rect, size of screen as defined background and wait till it is rendered
+    win.BeginRedraw();
+    TheGc->Activate(win);
+    TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+    TheGc->SetBrushColor(KRgbGreen);
+    TSize wSize = win.Size();
+    TheGc->DrawRect(TRect(TPoint(0,0), wSize));
+    TheGc->Deactivate();
+    win.EndRedraw();
+    TheClient->iWs.Finish();
+    
+    // #### do test ####
+    // define locations of simulated pointer events and sample positions of where we expect to see the cursor
+    // The cursor will be moved and a check will be made to see if this has actually happened
+    
+    TPoint pos1(wSize.iWidth / 2, wSize.iHeight / 2); // top left of cursor at centre screen
+    TPoint sample1(pos1 + bmSample); // centre of sprite at pos1
+    TPoint pos2 = pos1 - bmSize; // bottom right of cursor at centre screen
+    TPoint sample2 = pos2 + bmSample;  // centre of sprite at pos2
+
+    TRgb pixel;
+    
+    // check initial state of screen at both sample positions
+    TheClient->iScreen->GetPixel(pixel, sample1);
+    TEST(pixel == KRgbGreen);
+
+    TheClient->iScreen->GetPixel(pixel, sample2);
+    TEST(pixel == KRgbGreen);
+    
+    TRawEvent e; // to simulate pointer events
+
+    // simulate button 1 down event at pos1
+    e.Set(TRawEvent::EButton1Down, pos1.iX, pos1.iY);
+    e.SetDeviceNumber(screenNumber);
+    UserSvr::AddEvent(e);
+
+    User::After(eventPropagationDelay);
+    
+    // check red cursor visible on top of background
+    TheClient->iScreen->GetPixel(pixel, sample1);
+    TEST(pixel == KRgbRed);
+    
+    // simulate button 1 up event
+    e.Set(TRawEvent::EButton1Up, pos1.iX, pos1.iY);
+    UserSvr::AddEvent(e);
+    User::After(eventPropagationDelay);
+    
+    // Move cursor away to pos2 
+    e.Set(TRawEvent::EButton1Down, pos2.iX, pos2.iY);
+    e.SetDeviceNumber(screenNumber);
+    UserSvr::AddEvent(e);
+    
+    User::After(eventPropagationDelay);
+    
+    // check cursor has left this position ...
+    TheClient->iScreen->GetPixel(pixel, sample1);
+    TEST(pixel == KRgbGreen);
+    // and arrived at the correct place
+    TheClient->iScreen->GetPixel(pixel, sample2);
+    TEST(pixel == KRgbRed);
+
+    // simulate button 1 up event
+    e.Set(TRawEvent::EButton1Up, pos2.iX, pos2.iY);
+    UserSvr::AddEvent(e);
+    User::After(eventPropagationDelay);
+    
+    // remove the cursor
+    win.ClearPointerCursor();
+    User::After(eventPropagationDelay);
+    
+    // check it has gone
+    TheClient->iScreen->GetPixel(pixel, sample2);
+    TEST(pixel == KRgbGreen);
+    
+    // #### clean up ####
+    iCursor1.Close();
+    win.Close();
+    }
+
+
+/**
+	@SYMTestCaseID GRAPHICS-CODEBASE-WSERV-0053-0001
+  
+	@SYMPREQ PGM027
+  
+	@SYMTestCaseDesc Tests RWsPointerCursor::UpdateMember APIs. 
+   
+	@SYMTestPriority 1 
+  
+	@SYMTestStatus Implemented
+   
+	@SYMTestActions This test calls RWsPointerCursor::UpdateMember
+		
+	@SYMTestExpectedResults Should run properly with out any Panics.
+
+  */
+void CTTSprite::SpriteUpdateMemberTestsL()
+	{
+	RWsPointerCursor iCursor1;
+	
+	CFbsBitmap bitmap;
+	bitmap.Load(TEST_BITMAP_NAME,0);
+		
+	RWindow win(TheClient->iWs);
+	win.Construct(*TheClient->iGroup->GroupWin(),1);
+	win.Activate();
+
+	iCursor1=RWsPointerCursor(TheClient->iWs);
+	TSpriteMember member;
+	SetUpMember(member);
+	member.iBitmap=&bitmap;
+	User::LeaveIfError(iCursor1.Construct(0));
+	User::LeaveIfError(iCursor1.AppendMember(member));
+	User::LeaveIfError(iCursor1.Activate());
+	win.SetCustomPointerCursor(iCursor1);
+	iCursor1.UpdateMember(0);
+	
+	RWsPointerCursor iCursor2;
+	bitmap.Load(TEST_NEW_BITMAP_NAME,0);
+	iCursor2=RWsPointerCursor(TheClient->iWs);
+	User::LeaveIfError(iCursor2.Construct(0));
+	User::LeaveIfError(iCursor2.AppendMember(member));
+	User::LeaveIfError(iCursor2.Activate());
+	win.SetCustomPointerCursor(iCursor2);
+	iCursor2.UpdateMember(1);
+	
+	iCursor1.Close();
+	iCursor2.Close();
+	win.Close();
+	}
+
+/**
+	@SYMTestCaseID GRAPHICS-CODEBASE-WSERV-0054-0001
+  
+	@SYMPREQ PGM027
+  
+	@SYMTestCaseDesc Negative Tests RWsSpriteBase::UpdateMember API. 
+   
+	@SYMTestPriority 1 
+  
+	@SYMTestStatus Implemented
+   
+	@SYMTestActions This test calls RWsPointerCursor::UpdateMember
+		
+	@SYMTestExpectedResults Should run properly with out any Panics.
+
+ */
+void CTTSprite::SpriteUpdateMemberNegTestsL()
+	{
+	RWsPointerCursor iCursor1;
+	
+	CFbsBitmap bitmap;
+	bitmap.Load(TEST_BITMAP_NAME,0);
+		
+	RWindow win(TheClient->iWs);
+	win.Construct(*TheClient->iGroup->GroupWin(),1);
+	win.Activate();
+
+	iCursor1=RWsPointerCursor(TheClient->iWs);
+	TSpriteMember member;
+	SetUpMember(member);
+	member.iBitmap=&bitmap;
+	User::LeaveIfError(iCursor1.Construct(0));
+	User::LeaveIfError(iCursor1.AppendMember(member));
+	User::LeaveIfError(iCursor1.Activate());
+	win.SetCustomPointerCursor(iCursor1);
+	iCursor1.UpdateMember(-100);
+	
+	RWsPointerCursor iCursor2;
+	bitmap.Load(TEST_NEW_BITMAP_NAME,0);
+	iCursor2=RWsPointerCursor(TheClient->iWs);
+	User::LeaveIfError(iCursor2.Construct(0));
+	User::LeaveIfError(iCursor2.AppendMember(member));
+	User::LeaveIfError(iCursor2.Activate());
+	win.SetCustomPointerCursor(iCursor2);
+	iCursor2.UpdateMember(10000);
+	
+	iCursor1.Close();
+	iCursor2.Close();
+	win.Close();
+	}
+
+/**
+	@SYMTestCaseID GRAPHICS-CODEBASE-WSERV-0055-0001
+  
+	@SYMPREQ PGM027
+  
+	@SYMTestCaseDesc Tests FindWindowGroupIdentifier API. 
+   
+	@SYMTestPriority 1 
+  
+	@SYMTestStatus Implemented
+   
+	@SYMTestActions Create windows session and call FindWindowGroupIdentifier \n
+	with different thread Id's both with valid thread ids and in valid thread id's.
+	
+	@SYMTestExpectedResults Should run properly.
+
+ */	
+void CTTSprite::FindWindowGroupThreadTestsL()	
+	{
+	RThread proc;
+	TInt ident;
+	TUint64 id=proc.Id();
+	RWsSession ws1;
+	User::LeaveIfError(ws1.Connect());
+	CleanupClosePushL(ws1);
+	//Positive test for FindWindowGroupIdentifier
+	ident=ws1.FindWindowGroupIdentifier(0,id);
+	TEST(ws1.SetWindowGroupOrdinalPosition(ident,0)==KErrNone);
+	TEST(ws1.SetWindowGroupOrdinalPosition(ident,1)==KErrNone);
+	//Negative test for FindWindowGroupIdentifier
+    TInt ret=ws1.FindWindowGroupIdentifier(0,id+200);
+	TEST(ret==KErrNotFound);
+	#if defined __WINS__ || defined __WINSCW__
+	ret=ws1.FindWindowGroupIdentifier(0,-200);
+	TEST(ret==KErrNotFound);
+	#endif//defined __WINS__ || defined __WINSCW__
+	CleanupStack::PopAndDestroy(1, &ws1);
+	ws1.Close();
+	}	
+
+/**
+@SYMTestCaseID		GRAPHICS-WSERV-0462
+
+@SYMDEF  			PDEF114190
+
+@SYMTestCaseDesc    Test sprite list cleanup when a window is deleted in low memory conditions
+
+@SYMTestPriority    High
+
+@SYMTestStatus      Implemented
+
+@SYMTestActions     Have a loop which increases the number of allocations in the server thread before failure;
+					Within the loop:
+					1) Create a parent window and a child window of the parent;
+					2) Create a sprite on the child window; 
+					3) Delete the parent window only, but not the child window; 
+					4) Create a testWindow and do redraw on this window; 
+					5) Do redraw on the testWindow. This testWindow's redraw will force checking the sprite list. 
+					This would panic the client thread due to this defect because the sprite on the orphaned 
+					window (which is the previous child window) is still in the sprite list;
+					6) Delete all the windows involved.
+
+@SYMTestExpectedResults The sprite should be disabled when a window is deleted;
+						The client thread should not be panic'd.
+						The test should pass.
+*/
+void CTTSprite::SpriteOnWindowOrphanedTestsL()
+	{
+	TInt handles = 344;
+	TInt loop = 0;
+	TInt allocFailRate = 0;
+	TInt err = KErrNone;
+
+	CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;
+	CleanupStack::PushL(bitmap);
+	User::LeaveIfError(bitmap->Create(TSize(500, 500), EColor16MU));
+	TSpriteMember spritemember;
+	spritemember.iBitmap = bitmap;
+	spritemember.iMaskBitmap = NULL;	
+	
+	RWindowGroup group(TheClient->iWs);
+	RWindow parent1(TheClient->iWs);
+	RWindow child1(TheClient->iWs);
+	RWindow testWindow(TheClient->iWs);
+	RWsSprite sprite(TheClient->iWs);
+	
+	while (loop < 5)
+		{
+		TRect mainRect(TPoint(0,0), TSize(500,500));
+		err = group.Construct(++handles, EFalse);	
+		if (err == KErrNone)
+			{
+			TheClient->iWs.HeapSetFail(RHeap::EDeterministic, allocFailRate);
+
+			//Create parent 1
+			err = parent1.Construct(group,++handles);
+			if (err == KErrNone)
+				{
+				parent1.SetExtent(mainRect.iTl, mainRect.Size());
+				parent1.EnableRedrawStore(ETrue);
+				parent1.Activate();
+				}			
+			}
+		
+		//Create child 1
+		if (err == KErrNone)
+			{
+			TRect childRect(TPoint (10, 10), TSize (200, 150));
+			err = child1.Construct(parent1,++handles);
+			if (err == KErrNone)
+				{
+				child1.SetExtent(childRect.iTl, childRect.Size());
+				child1.SetBackgroundColor(TRgb(128,100,255,20));
+				child1.Activate();
+				}
+			}
+		
+		//Add sprite to child 1
+		if (err == KErrNone) 
+			{
+			err = sprite.Construct(child1,TPoint(10,10), 0);
+			if (err == KErrNone)
+				{
+				err = sprite.AppendMember(spritemember);
+				if (err == KErrNone)
+					err = sprite.Activate();	
+				}
+			}
+
+		//Only delete parent 1, but not child 1	
+		parent1.Close();		
+
+		if (err == KErrNone) 
+			{
+			TRect testRect(TPoint(10, 30), TSize(200, 150));
+			//Create testWindow
+			err = testWindow.Construct(group,++handles);
+			if (err == KErrNone)
+				{
+				testWindow.SetExtent(testRect.iTl, testRect.Size());
+				testWindow.SetBackgroundColor(TRgb(128,100,255,20));
+				testWindow.EnableRedrawStore(ETrue);
+				testWindow.Activate();
+				testWindow.BeginRedraw();
+				testWindow.EndRedraw();	
+				TheClient->Flush();			
+				}
+			}
+		TheClient->iWs.HeapSetFail(RAllocator::ENone, 0);
+
+		sprite.Close();
+		child1.Close();
+		testWindow.Close();
+		group.Close();		
+		++allocFailRate;
+		loop = (err == KErrNone) ? loop + 1 : 0;
+		}
+	CleanupStack::PopAndDestroy(bitmap);
+	}
+void CTTSprite::ResizeMemberL()
+	{
+#ifndef __WINS__
+	CTBlankWindow* win=new(ELeave) CTBlankWindow();
+	CleanupStack::PushL(win);
+	win->ConstructL(*TheClient->iGroup);
+	win->SetExt(TPoint(),TSize(640,240));
+	RWindowBase& window=*win->BaseWin();
+	window.Activate();
+	RWsSprite sprite(TheClient->iWs);
+	CleanupClosePushL(sprite);
+	User::LeaveIfError(sprite.Construct(window,TPoint(),0));
+	TSpriteMember member;
+	member.iMaskBitmap=NULL;
+	member.iInvertMask=EFalse;
+	member.iDrawMode=CGraphicsContext::EDrawModePEN;
+	member.iOffset=TPoint();
+	member.iInterval=TTimeIntervalMicroSeconds32(250000);
+	member.iBitmap=&iBitmap;
+	User::LeaveIfError(sprite.AppendMember(member));
+	User::LeaveIfError(sprite.AppendMember(member));
+	User::LeaveIfError(sprite.Activate());
+	User::After(1000000); // // Interval is 1 sec.
+	User::LeaveIfError(iBitmap.Resize(iBitmap.SizeInPixels() + TSize(100,100)));
+	User::After(1000000);  // Interval is 1 sec.
+	CleanupStack::PopAndDestroy(&sprite);
+	CleanupStack::PopAndDestroy(win);
+#endif // __WINS__
+	}
+
+
+void CTTSprite::SetUpSpriteL(RWsSprite &aSprite, RWindowTreeNode &aWindow,TPoint aPoint, TSpriteMember aMember, TInt aFlags/*=0*/)
+	{
+	User::LeaveIfError(aSprite.Construct(aWindow,aPoint,aFlags));
+	User::LeaveIfError(aSprite.AppendMember(aMember));
+	User::LeaveIfError(aSprite.Activate());
+	}
+/**
+@SYMTestCaseID		GRAPHICS-WSERV-00-0001
+
+@SYMDEF  			PDEF117721
+
+@SYMTestCaseDesc    Test Screenrotation does not cause panic by sprite with NULL bitmap and NULL maskbitmap
+
+@SYMTestPriority    High
+
+@SYMTestStatus      Implemented
+
+@SYMTestActions     Defines two sprites and one with Null iBitmap and Null iMaskBitmap, then rotate the screen to 90 degrees
+
+@SYMTestExpectedResults the screen rotation will not cause wserv a panic
+*/
+void CTTSprite::RotateNullSpriteL()
+	{
+	if (TheClient->iScreen->NumScreenModes() < 2)
+		{
+		LOG_MESSAGE(_L("WARNING: Unable to rotate screen"));
+		return;
+		}
+// Sprite Members		
+	TSpriteMember spriteMember1,spriteMember2;
+	SetUpMember(spriteMember1);
+	SetUpMember(spriteMember2);
+	spriteMember2.iBitmap = NULL;
+	
+// Create windows
+	RWindowGroup group(TheClient->iWs);
+	User::LeaveIfError(group.Construct(ENullWsHandle,EFalse));	//Creates a Group Window
+	CleanupClosePushL(group);
+	RBlankWindow win(TheClient->iWs);
+	User::LeaveIfError(win.Construct(group,ENullWsHandle));	//Creates a Blank Window
+	CleanupClosePushL(win);
+	win.SetVisible(ETrue);
+	win.SetColor(TRgb::Gray4(2));
+	win.Activate();
+	TheClient->Flush();
+	
+// Create Sprites
+	RWsSprite sprite1(TheClient->iWs);
+	CleanupClosePushL(sprite1);
+	SetUpSpriteL(sprite1, win,TPoint(20,70),spriteMember1,0);
+	RWsSprite sprite2(TheClient->iWs);
+	CleanupClosePushL(sprite2);
+	SetUpSpriteL(sprite2, win,TPoint(80,130),spriteMember2,0);
+	RWsSprite sprite3(TheClient->iWs);
+	CleanupClosePushL(sprite3);
+	SetUpSpriteL(sprite3, win,TPoint(2800,2130),spriteMember1,0);
+	TheClient->Flush();
+
+// Get the original screen mode	
+	CWsScreenDevice* device = TheClient->iScreen;
+	TInt originalScreenMode = device->CurrentScreenMode();
+	TPixelsTwipsAndRotation originalModeSettings;
+	device->GetScreenModeSizeAndRotation(originalScreenMode,originalModeSettings);
+
+// Rotate screens	
+	TPixelsAndRotation pixelsAndRotation;
+	device->SetScreenMode( 1 );
+	device->GetDefaultScreenSizeAndRotation(pixelsAndRotation);
+	device->SetCurrentRotations(1,pixelsAndRotation.iRotation);
+	device->SetScreenSizeAndRotation(pixelsAndRotation);
+	User::After(1000000);
+	
+	CleanupStack::PopAndDestroy(5,&group);
+//	Restore the original screen mode	
+	device->SetScreenMode(originalScreenMode);
+	device->SetCurrentRotations(originalScreenMode,originalModeSettings.iRotation);
+	device->SetScreenSizeAndRotation(originalModeSettings);
+	TheClient->Flush();
+	}
+
+/**
+@SYMTestCaseID		GRAPHICS-WSERV-GCE-0700
+
+@SYMDEF  			DEF123129
+
+@SYMTestCaseDesc    Test activating a sprite twice does not cause the system to hang
+
+@SYMTestPriority    High
+
+@SYMTestStatus      Implemented
+
+@SYMTestActions     Construct a sprite and add a member to it. Activate twice.
+
+@SYMTestExpectedResults The test should terminate smoothly and it should not hang the system.
+*/
+void CTTSprite::DoubleActivateL()
+	{
+	RWsSession ws;
+	User::LeaveIfError(ws.Connect());
+	CleanupClosePushL(ws);
+	
+	RWindowGroup group(ws);
+	User::LeaveIfError(group.Construct(890, EFalse));
+	CleanupClosePushL(group);
+	
+	RWsSprite sprite = RWsSprite(ws);
+	User::LeaveIfError(sprite.Construct(group,TPoint(),0));
+	CleanupClosePushL(sprite);
+	CFbsBitmap* bitmap=new(ELeave) CFbsBitmap;
+	CleanupStack::PushL(bitmap);
+	User::LeaveIfError(bitmap->Create(TSize(10,12),EColor256));
+	TSpriteMember member;
+	member.iMaskBitmap=NULL;
+	member.iInvertMask=EFalse;
+	member.iDrawMode=CGraphicsContext::EDrawModePEN;
+	member.iOffset=TPoint();
+	member.iInterval=TTimeIntervalMicroSeconds32(0);
+	member.iBitmap=bitmap;
+	User::LeaveIfError(sprite.AppendMember(member));
+	User::LeaveIfError(sprite.Activate());
+	User::LeaveIfError(sprite.Activate());
+	
+	sprite.Close();
+	CleanupStack::PopAndDestroy(4, &ws);
+	
+	group.Close();
+	ws.Close();
+	}
+
+void CTTSprite::RunTestCaseL(TInt /*aCurTestCase*/)
+	{	
+	_LIT(KTest1, "General Tests");
+	_LIT(KTest2, "Group Window Sprites Tests");
+	_LIT(KTest3, "Lots Sprites Tests");
+	_LIT(KTest4, "General Pointer Cursor Tests");
+    _LIT(KTest5, "Pointer Cursor Visible Tests");
+    _LIT(KTest6, "Update member tests");
+    _LIT(KTest7, "Negative tests for Update member");
+    _LIT(KTest8, "Window Group with Thread");
+    _LIT(KTest9, "Resize Sprite Member Tests");
+    _LIT(KTest10, "Rotate a NULL sprite");
+    _LIT(KTest11, "Sprite On Window Orphaned Tests");
+    _LIT(KTest12, "Sprite Double Activation Test");
+	
+	((CTTSpriteStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
+	switch(++iTest->iState)
+		{
+	case 1:		
+		((CTTSpriteStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0018"));
+		TheClient->iWs.SetFocusScreen(0);
+		iTest->LogSubTest(KTest1);
+		GeneralTestsL();
+		break;
+	case 2:
+		((CTTSpriteStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0019"));
+		iTest->LogSubTest(KTest2);
+		GroupWindowSpritesL();
+		break;
+	case 3:
+		((CTTSpriteStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0020"));
+		iTest->LogSubTest(KTest3);
+		LotsSpritesL();
+		break;
+	case 4:
+		((CTTSpriteStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0021"));
+		iTest->LogSubTest(KTest4);
+		GeneralPointerCursor();
+		break;
+    case 5:
+        ((CTTSpriteStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0498"));
+        iTest->LogSubTest(KTest5);
+        TRAPD(err, PointerCursorVisibleL());
+        TEST(err == KErrNone);
+        break;
+	case 6:
+		((CTTSpriteStep*)iStep)->SetTestStepID(_L("GRAPHICS-CODEBASE-WSERV-0053-0001"));
+		iTest->LogSubTest(KTest6);
+		TRAP(err, SpriteUpdateMemberTestsL());
+		TEST(err == KErrNone);
+		break;
+	case 7:
+		((CTTSpriteStep*)iStep)->SetTestStepID(_L("GRAPHICS-CODEBASE-WSERV-0054-0001"));
+		iTest->LogSubTest(KTest7);
+		TRAP(err, SpriteUpdateMemberNegTestsL());
+		TEST(err == KErrNone);
+		break;
+	case 8:
+		((CTTSpriteStep*)iStep)->SetTestStepID(_L("GRAPHICS-CODEBASE-WSERV-0055-0001"));
+		iTest->LogSubTest(KTest8);
+		TRAP(err, FindWindowGroupThreadTestsL());
+		TEST(err == KErrNone);
+		break;
+	case 9:
+		((CTTSpriteStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0526"));
+		iTest->LogSubTest(KTest9);
+		ResizeMemberL();
+		break;
+	case 10:
+		((CTTSpriteStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-00-0001"));
+		iTest->LogSubTest(KTest10);
+		RotateNullSpriteL();
+		break;
+	case 11:
+		((CTTSpriteStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0462"));
+		iTest->LogSubTest(KTest11);
+		SpriteOnWindowOrphanedTestsL();
+		break;
+	case 12:
+		((CTTSpriteStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-GCE-0700"));
+		iTest->LogSubTest(KTest12);
+		DoubleActivateL();
+		break;
+	default:
+		((CTTSpriteStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+		((CTTSpriteStep*)iStep)->CloseTMSGraphicsStep();
+		TestComplete();
+		break;
+		}
+	((CTTSpriteStep*)iStep)->RecordTestResultL();
+	}
+
+//--------------
+__WS_CONSTRUCT_STEP__(TSprite)
+