diff -r bf7481649c98 -r 7f25ef56562d windowing/windowserver/test/tauto/TSPRITE.CPP --- /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;iiiWs,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) +