Fix TRANSPARENCY_NONE composition for surfaces narrower than the context.
Improve performance of point sample scaling with 8-bit samples, by using fixed point code
Allow any non-zero value for the boolean attribute WFC_ELEMENT_SOURCE_FLIP
Simplify RemoveElement code
// 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:
// Test the text cursor.
//
// This suite of tests checks to see if the TextCursors are operating
// correctly for a number of use case scenarios; see doxygen comments
// for each sub-test. This test suite is applicable on both winscw
// emulator and armv5 target hardware. However, it must be noted that
// text cursors are special due to their timeliness. The text cursor
// must flash every second: half a second ON, half a second OFF. One
// consequence of this is that when the test suite is run on emulator,
// the PC must be otherwise quiescent. No other IO or CPU intensive
// activities may occur on the system, because these will cause delays
// to the flashing of the text cursor giving unreliable results.
// Where timeliness is a consideration, we use TEST_SOFTFAIL_WINSCW so
// that if the test fails and we are running on the PC emulator, we only
// record the fact, but don't mark the test as failing.
/**
@file
@test
@internalComponent - Internal Symbian test code
*/
#include "TTEXTCURS.H"
#include "graphics/windowserverconstants.h"
const TInt KNumberOfCustoTextCursors = 3;
const TInt KTextCursorInitialIdValue = 1001;
const TInt KTextCursorPanicUid1 = 200;
const TInt KTextCursorPanicUid2 = 2000;
const TInt KTextCursorPanicUid3 = 3000;
const TInt KTextCursorPanicUid4 = 4000;
const TInt KTextCursorPanicUid5 = 5000;
CTestBase* CTCursorTest::iStaticTest = NULL;
const TInt kWinWidth=400;
const TInt kWinHeight=100;
const TSize kWinSize(kWinWidth,kWinHeight);
const TInt kWinXPos=150;
const TInt kCursorWidth = 10;
const TInt kCursorHeight = 20;
const TSize kCursorSize(kCursorWidth,kCursorHeight);
const TPoint kWin1TopLeft(kWinXPos,0);
const TPoint kWin2TopLeft(kWinXPos,kWinHeight+10);
LOCAL_D void DeleteSpriteMember(TAny* aSpriteMember)
{
TSpriteMember* member=reinterpret_cast<TSpriteMember*>(aSpriteMember);
delete member->iBitmap;
member->iBitmap=NULL;
delete member->iMaskBitmap;
member->iMaskBitmap=NULL;
}
CCustomTextCursor::~CCustomTextCursor()
{
const TInt count = iSpriteMemberArray.Count();
for (TInt index=0; index<count; ++index)
{
DeleteSpriteMember(&iSpriteMemberArray[index]);
}
iSpriteMemberArray.Close();
}
CCustomTextCursor::CCustomTextCursor(CTestBase* aTest)
: iTest(aTest)
{
}
void CCustomTextCursor::ConstructL(TInt aScreenNumber,TInt aBmpIndex)
{
ASSERT(aBmpIndex < KNumberOfCustoTextCursors);
TSpriteMember spriteMember;
spriteMember.iBitmap = NULL;
spriteMember.iMaskBitmap = NULL;
spriteMember.iInvertMask =EFalse;
spriteMember.iDrawMode = CGraphicsContext::EDrawModePEN;
spriteMember.iOffset = TPoint();
spriteMember.iInterval = TTimeIntervalMicroSeconds32(0);
CleanupStack::PushL(TCleanupItem(DeleteSpriteMember, &spriteMember));
spriteMember.iBitmap = new (ELeave) CFbsBitmap;
User::LeaveIfError(spriteMember.iBitmap->Load(TEST_BITMAP_NAME, EMbmWsautotestBmp1));
spriteMember.iMaskBitmap = new (ELeave) CFbsBitmap;
User::LeaveIfError(spriteMember.iMaskBitmap->Load(TEST_BITMAP_NAME, EMbmWsautotestBmp1mask));
User::LeaveIfError(iSpriteMemberArray.Append(spriteMember));
CleanupStack::Pop(&spriteMember);
// create unique-id accross screens
//
iIdentifier = KTextCursorInitialIdValue + aScreenNumber*KNumberOfCustoTextCursors + aBmpIndex;
iAlignment = (RWsSession::TCustomTextCursorAlignment)(aBmpIndex);
}
CCustomTextCursor* CCustomTextCursor::CreateCustomTextCursorL(TInt aScreenNumber,TInt aBmpIndex,CTestBase* aTest)
{
CCustomTextCursor* customTextCursor = new (ELeave) CCustomTextCursor(aTest);
CleanupStack::PushL(customTextCursor);
customTextCursor->ConstructL(aScreenNumber,aBmpIndex);
CleanupStack::Pop(customTextCursor);
return customTextCursor;
}
/*
* Wrapper class for a list of custom text cursor.
*/
class CCustomTextCursorsWrapper : public CBase
{
public:
static CCustomTextCursorsWrapper* NewLC(TInt aScreenNumber,CTestBase* aTest);
~CCustomTextCursorsWrapper();
inline RPointerArray<CCustomTextCursor>& CustomTextCursorsArray();
inline CCustomTextCursor& CustomTextCursor(TInt aIndex);
private:
void ConstructL(TInt aScreenNumber,CTestBase* aTest);
private:
RPointerArray<CCustomTextCursor> iCustomTextCursors;
};
inline RPointerArray<CCustomTextCursor>& CCustomTextCursorsWrapper::CustomTextCursorsArray()
{
return iCustomTextCursors;
}
inline CCustomTextCursor& CCustomTextCursorsWrapper::CustomTextCursor(TInt aIndex)
{
return *(iCustomTextCursors[aIndex]);
}
CCustomTextCursorsWrapper* CCustomTextCursorsWrapper::NewLC(TInt aScreenNumber,CTestBase* aTest)
{
CCustomTextCursorsWrapper* self = new(ELeave) CCustomTextCursorsWrapper();
CleanupStack::PushL(self);
self->ConstructL(aScreenNumber,aTest);
return self;
}
CCustomTextCursorsWrapper::~CCustomTextCursorsWrapper()
{
iCustomTextCursors.ResetAndDestroy();
iCustomTextCursors.Close();
}
void CCustomTextCursorsWrapper::ConstructL(TInt aScreenNumber, CTestBase* aTest)
{
for (TInt index=0; index<KNumberOfCustoTextCursors; ++index)
{
CCustomTextCursor* customTextCursor=CCustomTextCursor::CreateCustomTextCursorL(aScreenNumber,index, aTest);
CleanupStack::PushL(customTextCursor);
User::LeaveIfError(iCustomTextCursors.Append(customTextCursor));
CleanupStack::Pop(customTextCursor);
}
}
CTCursorTest::CTCursorTest(CTestStep* aStep) :
CTWsGraphicsBase(aStep)
{
iCursorType = TTextCursor::ETypeFirst;
iStaticTest=iTest;
}
CTCursorTest::~CTCursorTest()
{
delete iWorkInProgress;
delete iComparisonWindow;
}
TInt CTCursorTest::DoPanicTest(TInt aInt, TAny *aScreenNumber)
{
RWsSession ws;
if (ws.Connect()==KErrNone)
{
// use correct screen
CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws);
User::LeaveIfError(screen->Construct((TInt)aScreenNumber));
RWindowGroup group(ws);
if (group.Construct(444)==KErrNone)
{
group.EnableReceiptOfFocus(EFalse); // Stop auto group switching on close
RWindow wnd(ws);
if (wnd.Construct(group, TInt32(&ws))==KErrNone)
{
TTextCursor tc;
tc.iHeight=10;
tc.iAscent=5;
tc.iWidth=10;
tc.iFlags=0;
tc.iColor=TRgb(0,0,0);
switch(aInt)
{
case 0:
{
/* TESTCASE: 6.1
* TITLE: Invalid use of a custom text cursor ID (basic text cursor).
* IMPORTANCE: 1
* REQUIREMENT: Unknown.
*
* ACTION: This test tries to set a text cursor using an ID which is invalid.
*
* CHECK: The thread should panic with the exit reason EWservPanicInvalidTextCursor
*/
tc.iType=(TTextCursor::EType)KTextCursorPanicUid1;
group.SetTextCursor(wnd,TPoint(10,10),tc);
}
break;
case 1:
{
/* TESTCASE: 6.2
* TITLE: Invalid use of a window for a text cursor.
* IMPORTANCE: 1
* REQUIREMENT: REQ 1079, CR RDEF-5F7Q24 (10/04/2003).
*
* ACTION: This test tries to set a text cursor using a window which is not part
* of the window group calling the setting API.
*
* CHECK: The thread should panic with the exit reason EWservPanicWindow
*/
tc.iType=(TTextCursor::EType)KTextCursorPanicUid2;
group.SetTextCursor(*TestWin->Win(),TPoint(10,10),tc);
}
break;
case 2:
{
/* TESTCASE: 6.3
* TITLE: Invalid use of a custom text cursor ID.
* IMPORTANCE: 1
* REQUIREMENT: REQ 1079, CR RDEF-5F7Q24 (10/04/2003).
*
* ACTION: This test tries to set a text cursor using an ID which is associated to
* an non-existing custom text cursor.
*
* CHECK: The thread should panic with the exit reason EWservPanicNoCustomTextCursor
*/
tc.iType=(TTextCursor::EType)KTextCursorPanicUid3;
group.SetTextCursor(wnd,TPoint(10,10),tc);
}
break;
case 3:
{
/* TESTCASE: 6.4
* TITLE: Invalid use of a custom text cursor ID.
* IMPORTANCE: 1
* REQUIREMENT: REQ 1079, CR RDEF-5F7Q24 (10/04/2003).
*
* ACTION: This test tries to set a custom text cursor which has been set to use
* an invalid alignment.
*
* CHECK: The thread should panic with the exit reason EWservPanicCustomTextCursorAlign
*/
CCustomTextCursor* customTextCursor=NULL;
TRAPD(error, customTextCursor=CCustomTextCursor::CreateCustomTextCursorL((TInt)aScreenNumber,0,iStaticTest));
if (error==KErrNone)
{
error = ws.SetCustomTextCursor(KTextCursorPanicUid4, customTextCursor->iSpriteMemberArray.Array(), 0, (RWsSession::TCustomTextCursorAlignment)(RWsSession::ECustomTextCursorAlignBottom+1));
if (error==KErrNone || error==KErrAlreadyExists)
{
tc.iType=(TTextCursor::EType)KTextCursorPanicUid4;
group.SetTextCursor(wnd,TPoint(10,10),tc);
}
}
delete customTextCursor;
}
break;
case 4:
{
/* TESTCASE: 6.5
* TITLE: Use of an invalid custom text cursor
* IMPORTANCE: 1
* REQUIREMENT: REQ 1079, CR RDEF-5F7Q24 (10/04/2003).
*
* ACTION: This test tries to set a custom text cursor which does not have
* any sprite member set.
*
* CHECK: The thread should panic with the exit reason EWservPanicNoSpriteMember
*/
RArray<TSpriteMember> spriteMemberArray;
const TInt error = ws.SetCustomTextCursor(KTextCursorPanicUid5, spriteMemberArray.Array(), 0, (RWsSession::TCustomTextCursorAlignment)(RWsSession::ECustomTextCursorAlignBottom));
if (error==KErrNone || error==KErrAlreadyExists)
{
tc.iType=(TTextCursor::EType)KTextCursorPanicUid5;
group.SetTextCursor(wnd,TPoint(10,10),tc);
}
}
break;
case 5:
{
// Uncover set.cursor.iType < TTextCursor::ETypeFirst code path
tc.iType=(TTextCursor::EType)TTextCursor::ETypeFirst - 1;
group.SetTextCursor(wnd,TPoint(10,10),tc);
}
break;
case 6:
{
// Uncover (set.cursor.iFlags&static_cast<TUint>(TTextCursor::EPrivateFlags) code path
tc.iFlags=ETextCursorPrivateFlags;
group.SetTextCursor(wnd,TPoint(10,10),tc);
}
break;
case 7:
{
// Uncover (iGroupWin != searchWin) i.e. bogus group window
tc.iType=(TTextCursor::EType)TTextCursor::ETypeRectangle;
RWindow windowNotAssociatedWithAGroup(ws);
group.SetTextCursor(windowNotAssociatedWithAGroup, TPoint(10,10),tc);
}
break;
}
}
ws.Flush();
}
}
return(EWsExitReasonBad);
}
void CTCursorTest::TestPanicsL()
{
TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicInvalidTextCursor, 0, (TAny*)iTest->iScreenNumber));
TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicWindow, 1, (TAny*)iTest->iScreenNumber));
TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicNoCustomTextCursor, 2, (TAny*)iTest->iScreenNumber));
TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicCustomTextCursorAlign, 3, (TAny*)iTest->iScreenNumber));
TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicNoSpriteMember, 4, (TAny*)iTest->iScreenNumber));
TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicInvalidTextCursor, 5, (TAny*)iTest->iScreenNumber));
TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicInvalidTextCursor, 6, (TAny*)iTest->iScreenNumber));
TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicWindow, 7, (TAny*)iTest->iScreenNumber));
iTest->CloseAllPanicWindows();
}
void CTCursorTest::TextCursorSetLCoverageTests()
{
ValidateWin(BaseWin,TRgb::Gray256(255));
ValidateWin(TestWin,TRgb::Gray256(255));
TTextCursor textCursor;
textCursor.iHeight = 10;
textCursor.iAscent = 0;
textCursor.iWidth = 10;
textCursor.iFlags = 0;
textCursor.iColor = KRgbBlack;
textCursor.iType = (TTextCursor::EType)TTextCursor::ETypeRectangle;
TPoint position(10, 10);
TRect clipRect0(10, 10, 10, 10);
TRect clipRect1(10, 10, 5, 5);
RWindowGroup *group = TheClient->iGroup->GroupWin();
group->SetTextCursor(*TestWin->Win(), position, textCursor);
/*
* Duplicate the previous SetTextCursor command to uncover the code which checks for any delta in SetL
* compared to the current settings.
*/
group->SetTextCursor(*TestWin->Win(), position, textCursor);
/*
* Change the type only to pick up that difference in SetL.
*/
textCursor.iType++;
group->SetTextCursor(*TestWin->Win(), position, textCursor);
textCursor.iType--;
/*
* Vary the clipping rectangle.
*/
group->SetTextCursor(*TestWin->Win(), position, textCursor, clipRect0);
group->SetTextCursor(*TestWin->Win(), position, textCursor, clipRect1);
/*
* Vary the color.
*/
textCursor.iColor = KRgbGreen;
group->SetTextCursor(*TestWin->Win(), position, textCursor);
textCursor.iColor = KRgbBlack;
group->SetTextCursor(*TestWin->Win(), position, textCursor);
/*
* Vary the target Window.
*/
group->SetTextCursor(*BaseWin->Win(), position, textCursor);
group->SetTextCursor(*TestWin->Win(), position, textCursor);
/*
* Vary the size of the cursor.
*/
textCursor.iWidth++;
group->SetTextCursor(*TestWin->Win(), position, textCursor);
textCursor.iWidth--;
/*
* Set different custom cursors.
*/
CCustomTextCursorsWrapper* customTextCursorsWrapper = CCustomTextCursorsWrapper::NewLC(iTest->iScreenNumber, iTest);
const TInt count = customTextCursorsWrapper->CustomTextCursorsArray().Count();
for (TInt index=0; index<count; ++index)
{
CCustomTextCursor& customTextCursor = customTextCursorsWrapper->CustomTextCursor(index);
textCursor.iType = customTextCursor.iIdentifier;
group->SetTextCursor(*TestWin->Win(), position, textCursor);
}
CleanupStack::PopAndDestroy(customTextCursorsWrapper);
/*
* Set the last custom cursor from the above loop again so the
* product code sees the same Custom Text Cursor settings come
* in a second time.
*/
group->SetTextCursor(*TestWin->Win(), position, textCursor);
textCursor.iType = (TTextCursor::EType)TTextCursor::ETypeRectangle;
/*
* Vary the horizontal clipping.
*/
textCursor.iFlags = TTextCursor::EFlagClipHorizontal;
group->SetTextCursor(*TestWin->Win(), position, textCursor);
/*
* Vary the horizontal clipping.
*/
textCursor.iFlags = TTextCursor::EFlagClipVertical;
group->SetTextCursor(*TestWin->Win(), position, textCursor);
/*
* Try both horizontal and vertical clipping.
*/
textCursor.iFlags = TTextCursor::EFlagClipVertical|TTextCursor::EFlagClipHorizontal;
group->SetTextCursor(*TestWin->Win(), position, textCursor);
textCursor.iFlags = 0;
TheClient->iWs.Flush();
CancelTextCursor();
}
void CTCursorTest::SetCursor(const TPoint &aPos,const TSize &aSize,TRgb aColor, const TRect &aRect, TUint aFlags)
{
TTextCursor tc;
tc.iType=iCursorType;
tc.iHeight=aSize.iHeight;
tc.iAscent=aSize.iHeight*4/5;
tc.iWidth=aSize.iWidth;
tc.iFlags=aFlags;
tc.iColor=aColor;
TheClient->iGroup->GroupWin()->SetTextCursor(*TestWin->Win(),TPoint(aPos.iX,aPos.iY+tc.iAscent),tc,aRect);
}
void CTCursorTest::SetCursor(const TPoint &aPos,const TSize &aSize,TRgb aColor, TUint aFlags)
{
TTextCursor tc;
tc.iType=iCursorType;
tc.iHeight=aSize.iHeight;
tc.iAscent=aSize.iHeight*4/5;
tc.iWidth=aSize.iWidth;
tc.iFlags=aFlags;
tc.iColor=aColor;
TheClient->iGroup->GroupWin()->SetTextCursor(*TestWin->Win(),TPoint(aPos.iX,aPos.iY+tc.iAscent),tc);
}
void CTCursorTest::SetCursorPlusBox(const TPoint &aPos,const TSize &aSize,TRgb aColor, const TRect *aClipRect, TUint aFlags)
{
if (aClipRect)
SetCursor(aPos,aSize,aColor,*aClipRect,aFlags);
else
SetCursor(aPos,aSize,aColor,aFlags);
TRect rect(aPos,aSize);
if (aClipRect)
rect.Intersection(*aClipRect);
rect.Grow(2,2);
TheClient->iGc->Activate(*(TestWin->Win()));
TestWin->Invalidate(rect);
TestWin->Win()->BeginRedraw(rect);
TheClient->iGc->SetPenColor(aColor);
TheClient->iGc->SetDrawMode(CGraphicsContext::EDrawModeXOR);
TheClient->iGc->DrawRect(rect);
TheClient->iGc->Deactivate();
TestWin->Win()->EndRedraw();
}
void CTCursorTest::CancelTextCursor()
{
TheClient->iGroup->GroupWin()->CancelTextCursor();
}
void CTCursorTest::ConstructL()
{
// for allocating some cached memory
CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
CleanupStack::PushL(bitmap);
User::LeaveIfError(bitmap->Load(TEST_BITMAP_NAME, 0));
CleanupStack::PopAndDestroy(bitmap);
CCustomTextCursorsWrapper* customTextCursorsWrapper = CCustomTextCursorsWrapper::NewLC(iTest->iScreenNumber, iTest);
const TInt count = customTextCursorsWrapper->CustomTextCursorsArray().Count();
for (TInt index=0; index<count; ++index)
{
CCustomTextCursor& customTextCursor = customTextCursorsWrapper->CustomTextCursor(index);
TInt err = TheClient->iWs.SetCustomTextCursor(customTextCursor.iIdentifier, customTextCursor.iSpriteMemberArray.Array(), customTextCursor.iSpriteFlags, customTextCursor.iAlignment);
TEST(err == KErrNone || err == KErrAlreadyExists);
if (err!=KErrNone && err != KErrAlreadyExists)
INFO_PRINTF4(_L("TheClient->iWs.SetCustomTextCursor return value - Expected: %d or %d, Actual: %d"), KErrNone, KErrAlreadyExists, err);
__UHEAP_MARK;
err = TheClient->iWs.SetCustomTextCursor(customTextCursor.iIdentifier, customTextCursor.iSpriteMemberArray.Array(), customTextCursor.iSpriteFlags, customTextCursor.iAlignment);
__UHEAP_MARKEND;
TEST(err == KErrAlreadyExists);
if (err != KErrAlreadyExists)
INFO_PRINTF3(_L("TheClient->iWs.SetCustomTextCursor return value - Expected: %d, Actual: %d"), KErrAlreadyExists, err);
}
_LIT(KLog,"Text Cursor: Loaded %d Custom Cursors");
TLogMessageText buf;
buf.Format(KLog,count);
TheClient->LogMessage(buf);
CleanupStack::PopAndDestroy(customTextCursorsWrapper);
//
ValidateWin(BaseWin,TRgb::Gray256(204));
ValidateWin(TestWin,TRgb::Gray256(204));
//
SetCursor(TPoint(10,90),TSize(80,100),TRgb(255,255,255));
//
iWinState=0;
iWinPos=TPoint(2*TheClient->iGroup->Size().iWidth/3,0);
//
iMoveWin=new(ELeave) CBlankWindow(TRgb::Gray256(220));
TDisplayMode mode=EGray16;
TInt testWinWidth = TestWin->Size().iWidth;
TInt halfTestWinWidth = testWinWidth/2;
TInt halfTestWinHeight = TestWin->Size().iHeight/2;
iMoveWin->SetUpL(iWinPos,TSize(halfTestWinHeight,halfTestWinHeight),
TheClient->iGroup,*TheClient->iGc,&mode);
iCheckWin=new(ELeave) CBlankWindow(TRgb::Gray256(220));
iCheckWin->SetUpL(TPoint(testWinWidth+halfTestWinWidth,halfTestWinHeight),
TSize(halfTestWinWidth,halfTestWinHeight),
TheClient->iGroup,*TheClient->iGc,&mode);
}
void CTCursorTest::DeleteMoveWindows()
{
delete iMoveWin;
delete iCheckWin;
CancelTextCursor();
}
void CTCursorTest::ResetMoveWindowsL()
{
SetCursor(TPoint(10,90),TSize(80,100),TRgb(255,255,255));
iWinState=0;
iWinPos=TPoint(2*TheClient->iGroup->Size().iWidth/3,0);
iMoveWin->SetExtL(iWinPos,TSize(TestWin->Size().iWidth/2,TestWin->Size().iHeight/2));
iCheckWin->SetExtL(TPoint(TestWin->Size().iWidth+(TestWin->Size().iWidth>>1),TestWin->Size().iHeight>>1),
TSize(TestWin->Size().iWidth/2,TestWin->Size().iHeight/2));
}
TBool CTCursorTest::MoveWindow()
{
TSize scrSize(TheClient->iScreen->SizeInPixels());
iWinState++;
if (iWinState<20)
iWinPos+=TPoint((4*scrSize.iWidth)/640,(4*scrSize.iHeight)/240);
else if (iWinState<40)
iWinPos+=TPoint((1*scrSize.iWidth)/640,(-3*scrSize.iHeight)/240);
else if (iWinState<60)
iWinPos+=TPoint((-6*scrSize.iWidth)/640,(3*scrSize.iHeight)/240);
else
iWinPos+=TPoint((1*scrSize.iWidth)/640,(-2*scrSize.iHeight)/240);
iMoveWin->SetPos(iWinPos);
return (iWinState==80);
}
void CTCursorTest::ValidateWin(TestWindow *aWin, TRgb aColor)
{
aWin->Win()->Invalidate();
RedrawWin(*aWin->Win(),aColor);
}
void CTCursorTest::RedrawWin(RWindow &aWin, TRgb aColor)
{
aWin.BeginRedraw();
TheClient->iGc->Activate(aWin);
TheClient->iGc->SetBrushColor(aColor);
TheClient->iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
TheClient->iGc->SetPenStyle(CGraphicsContext::ENullPen);
TheClient->iGc->Clear();
TheClient->iGc->Deactivate();
aWin.EndRedraw();
}
void CTCursorTest::ScrollTest()
{
const TSize size(20,40);
ValidateWin(TestWin,TRgb::Gray256(255));
SetCursor(TPoint(10,20),size,TRgb::Gray256(255),TTextCursor::EFlagNoFlash);
TheClient->iWs.Flush();
TheClient->WaitForRedrawsToFinish();
TheClient->iWs.Finish();
for(TInt ii=0;ii<20;ii++)
{
TInt dist=(ii&3)*2;
TInt nx=ii&0x1?1:-1;
TInt ny=ii&0x2?1:-1;
TestWin->Win()->Scroll(TPoint(dist*nx,dist*ny),TRect(10,20,30,40));
TheClient->iWs.Flush();
}
TheClient->WaitForRedrawsToFinish();
TheClient->iWs.Finish();
BaseWin->Win()->Invalidate();
BaseWin->Win()->BeginRedraw();
TheClient->iGc->Activate(*(BaseWin->Win()));
TheClient->iGc->Clear();
TheClient->iGc->SetBrushColor(TRgb::Gray256(255));
TheClient->iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
TheClient->iGc->SetPenStyle(CGraphicsContext::ENullPen);
TheClient->iGc->Clear(TRect(TPoint(10,20),size));
TheClient->iGc->Deactivate();
BaseWin->Win()->EndRedraw();
TheClient->iWs.Flush();
TheClient->WaitForRedrawsToFinish();
TheClient->iWs.Finish();
/*
* NOTE: Reason for removal of COMPARE_WINDOWS_SOFTFAIL_WINSCW
* Due to the new implementation of sprites in wserv2, the sprites no longer keep a
* backup bitmap of what the screen looks like beneath them. As it is not possible to
* move the sprites associated with the custom text cursors that were created in second
* phase construction of the CTCursorTest object, the COMPARE_WINDOWS_SOFTFAIL_WINSCW;
* macro function has been removed. Otherwise the test case is going to subject to the
* timing of the flashing sprite. An alternative solution would be to assign NULL values
* to the sprite bitmaps in second phase construction, but this is avoided as it would
* trigger failures in some test cases later on (that are depended on these "embedded"
* sprite images).
*/
CancelTextCursor();
}
void DrawTestSprite(CBitmapContext *aGc,TInt , const TSize &aSize, TBool aDoMask, TAny *)
{
aGc->SetBrushColor(TRgb::Gray4(aDoMask ? 0 : 2));
aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
aGc->SetPenStyle(CGraphicsContext::ENullPen);
aGc->DrawRect(TRect(aSize));
aGc->SetPenStyle(CGraphicsContext::ESolidPen);
aGc->SetPenColor(TRgb::Gray4(aDoMask ? 3 : 0));
aGc->SetBrushColor(TRgb::Gray4(aDoMask ? 3 : 1));
aGc->DrawEllipse(TRect(aSize));
}
CTSprite *CTCursorTest::CreateTestSpriteLC(RWindowTreeNode &aWindow, const TPoint &aPos, TInt aCount)
//
// At the moment aCount must be 1 or 2
//
{
TSpriteCreateParams params(TSize(30,70),TPoint(0,0),DrawTestSprite);
TSpriteCreateParams paramarray[2];
params.iInterval=TTimeIntervalMicroSeconds32(200000);
paramarray[0]=params;
paramarray[1]=params;
paramarray[1].iSize=TSize(100,10);
CTSprite *sprite=new(ELeave) CTSprite(TheClient->iWs);
CleanupStack::PushL(sprite);
sprite->ConstructL(aWindow,aPos,aCount,¶marray[0],0);
return(sprite);
}
void CTCursorTest::doMoveWindowTestL()
{
RBlankWindow blankwin(TheClient->iWs);
User::LeaveIfError(blankwin.Construct(*TestWin->Win(),1));
CleanupStack::PushL(TCleanupItem(CleanUpWindow,&blankwin));
//
blankwin.SetExtent(TPoint(35,165),TSize(40,40));
blankwin.SetColor(TRgb::Gray256(220));
blankwin.Activate();
TheClient->iWs.SetAutoFlush(ETrue);
User::After(500000);
blankwin.SetPosition(TPoint(25,55));
User::After(500000);
blankwin.SetPosition(TPoint(30,160));
User::After(500000);
blankwin.SetPosition(TPoint(12,22)); // Almost totally covering sprite
User::After(500000);
blankwin.SetPosition(TPoint(-100,-100)); // Totally off the sprite
User::After(500000);
blankwin.SetPosition(TPoint(10,20)); // Write on top of sprite
User::After(500000);
blankwin.SetPosition(TPoint(24,24)); // moving off...
User::After(500000);
blankwin.SetPosition(TPoint(38,28)); // ...
User::After(500000);
blankwin.SetPosition(TPoint(58,48)); // ...
User::After(500000);
blankwin.SetPosition(TPoint(92,62)); // ... off
User::After(500000);
CleanupStack::PopAndDestroy(); // blank window
TheClient->iWs.Flush();
TheClient->WaitForRedrawsToFinish();
TheClient->iWs.Finish();
TheClient->iWs.SetAutoFlush(EFalse);
}
void CTCursorTest::MoveWindowTest1L()
{
ValidateWin(TestWin,TRgb::Gray256(255));
// Check it with a static sprite
CTSprite * sprite_static = CreateTestSpriteLC(*TestWin->Win(), TPoint(10,20), 1);
doMoveWindowTestL();
(sprite_static->Sprite()).SetPosition(TPoint(500,500)); //move the sprite out of the viewing area before the window comparison
CleanupStack::PopAndDestroy(1); // sprite
// Check it an animated sprite
CTSprite * sprite_anim = CreateTestSpriteLC(*TestWin->Win(), TPoint(10,20), 2);
doMoveWindowTestL();
(sprite_anim->Sprite()).SetPosition(TPoint(500,500)); //move the sprite out of the viewing area before the window comparison
CleanupStack::PopAndDestroy(1); // sprite
}
void CTCursorTest::MoveWindowTest2L()
{
const TSize size(20,40);
// Check it with a text cursor
ValidateWin(TestWin,TRgb::Gray256(255));
SetCursor(TPoint(10,25),size,TRgb::Gray256(255),TTextCursor::EFlagNoFlash);
doMoveWindowTestL();
CancelTextCursor();
// Check it with an anaimated sprite and a text cursor
ValidateWin(TestWin,TRgb::Gray256(255));
CTSprite * sprite_anim = CreateTestSpriteLC(*TestWin->Win(), TPoint(10,20), 2);
SetCursor(TPoint(10,45),size,TRgb::Gray256(255),TTextCursor::EFlagNoFlash);
doMoveWindowTestL();
(sprite_anim->Sprite()).SetPosition(TPoint(500,500));
CancelTextCursor();
CleanupStack::PopAndDestroy(1); // sprite
}
TBool CTCursorTest::IncrementCursorType()
{
// each screen has it own set of cursor
//
// the values would be ETypeLast=2 ETypeLastBasic=1009
//
if (iCursorType == TTextCursor::ETypeFirst)
{
iCursorType = (TTextCursor::EType)(TTextCursor::ETypeLastBasic + 1 + iTest->iScreenNumber*KNumberOfCustoTextCursors);
return ETrue;
}
else if (iCursorType >= TTextCursor::ETypeLastBasic + (iTest->iScreenNumber+1)*KNumberOfCustoTextCursors)
{
iCursorType = TTextCursor::ETypeFirst;
return EFalse;
}
else
{
iCursorType = (TTextCursor::EType)(iCursorType + 1);
return ETrue;
}
}
void CTCursorTest::GeneralTestsL()
{
const TInt winColor=255; //Best to use Light Grey that is 170, but this code is bugged and doing so shows them up.
ValidateWin(BaseWin,TRgb::Gray256(255));
ValidateWin(TestWin,TRgb::Gray256(255));
SetCursor(TPoint(-1000,10),TSize(10,30),TRgb::Gray256(255));
TheClient->iWs.Flush();
SetCursor(TPoint(10,10),TSize(10,30),TRgb::Gray256(255));
TheClient->iWs.Flush();
TRect rect(15,15,18,25);
SetCursorPlusBox(TPoint(10,10),TSize(10,30),TRgb::Gray256(255), &rect);
CancelTextCursor();
//
ValidateWin(BaseWin,TRgb::Gray256(255));
ValidateWin(TestWin,TRgb::Gray256(255));
TheClient->iWs.Flush();
for(TInt winType=0;winType<3;winType++)
{
RWindowBase *cursorwin=NULL;
RBackedUpWindow backcursorwin(TheClient->iWs);
RWindow backwindow(TheClient->iWs);
RBlankWindow backblankwin(TheClient->iWs);
switch(winType)
{
case 0:
cursorwin=&backcursorwin;
User::LeaveIfError(backcursorwin.Construct(*TestWin->BaseWin(),EGray4,1));
break;
case 1:
cursorwin=&backwindow;
User::LeaveIfError(backwindow.Construct(*TestWin->BaseWin(),1));
break;
case 2:
cursorwin=&backblankwin;
User::LeaveIfError(backblankwin.Construct(*TestWin->BaseWin(),1));
break;
}
CleanupStack::PushL(TCleanupItem(CleanUpWindow,cursorwin));
User::LeaveIfError(cursorwin->SetSizeErr(TestWin->BaseWin()->Size()));
cursorwin->Activate();
//
TTextCursor tc;
tc.iType=iCursorType;
tc.iHeight=30;
tc.iAscent=0;
tc.iWidth=50;
tc.iFlags=0;
tc.iColor=TRgb::Gray256(255);
TheClient->iGroup->GroupWin()->SetTextCursor(*cursorwin,TPoint(10,10),tc);
//
CreateTestSpriteLC(*cursorwin, TPoint(10,20), 2);
//
if (cursorwin==&backwindow)
RedrawWin(backwindow,TRgb::Gray256(255));
for(TInt count=0;count<9;count++)
{
RWindowBase *pwin=NULL;
RBackedUpWindow backedup(TheClient->iWs);
RWindow window(TheClient->iWs);
RBlankWindow blankwin(TheClient->iWs);
switch(count%3)
{
case 0:
pwin=&window;
window.Construct(*cursorwin,2);
window.SetBackgroundColor(TRgb(winColor,winColor,winColor));
break;
case 1:
pwin=&backedup;
backedup.Construct(*cursorwin,EGray4,2);
break;
case 2:
pwin=&blankwin;
blankwin.Construct(*cursorwin,2);
blankwin.SetColor(TRgb(winColor,winColor,winColor));
break;
}
CleanupStack::PushL(TCleanupItem(CleanUpWindow,pwin));
pwin->SetExtentErr(TPoint(30,30),TSize(50,80));
pwin->Activate();
TheClient->iWs.Flush();
CleanupStack::PopAndDestroy(); // window
if (cursorwin==&backwindow)
RedrawWin(backwindow,TRgb::Gray256(255));
TheClient->iWs.Flush();
TheClient->WaitForRedrawsToFinish();
COMPARE_WINDOWS_SOFTFAIL_WINSCW;
User::After(200000); // Wait a fifth of a second to make sure the test is run during different states of flashing
}
for(TInt count2=0;count2<4;count2++)
{
cursorwin->SetPosition(TPoint(10,5));
TheClient->iWs.Flush();
User::After(100000);
cursorwin->SetPosition(TPoint(5,10));
TheClient->iWs.Flush();
User::After(100000);
cursorwin->SetPosition(TPoint(0,0));
TheClient->iWs.Flush();
User::After(100000);
TheClient->WaitForRedrawsToFinish();
COMPARE_WINDOWS_SOFTFAIL_WINSCW;
}
CleanupStack::PopAndDestroy(2); // sprite & window containing sprite and cursor
}
CancelTextCursor();
}
void CTCursorTest::INC040489L()
{
INFO_PRINTF1(_L("AUTO_TCur INC040489 "));
RWindowGroup group1(TheClient->iWs);
PushWindowL(&group1);
User::LeaveIfError(group1.Construct(ENullWsHandle));
RBlankWindow blank1(TheClient->iWs);
PushWindowL(&blank1);
User::LeaveIfError(blank1.Construct(group1,ENullWsHandle));
blank1.SetRequiredDisplayMode(EColor4K);
blank1.SetColor(TRgb(250,150,0));
blank1.Activate();
RWindowGroup group2(TheClient->iWs);
PushWindowL(&group2);
User::LeaveIfError(group2.Construct(ENullWsHandle));
RBlankWindow blank2(TheClient->iWs);
PushWindowL(&blank2);
User::LeaveIfError(blank2.Construct(group2,ENullWsHandle));
blank2.SetRequiredDisplayMode(EColor4K);
blank2.SetColor(TRgb(75,200,125));
blank2.Activate();
TheClient->Flush();
INFO_PRINTF1(_L(" Created Windows "));
TTextCursor tc;
tc.iType=KTextCursorInitialIdValue + iTest->iScreenNumber*KNumberOfCustoTextCursors;
tc.iHeight=80;
tc.iAscent=10;
tc.iWidth=30;
tc.iFlags=0;
tc.iColor=TRgb::Gray256(255);
INFO_PRINTF1(_L(" About to Set Text Cursor 1 "));
group2.SetTextCursor(blank2,TPoint(20,20),tc);
TheClient->Flush();
INFO_PRINTF1(_L(" Set Text Cursor 1 "));
User::After(2000000); //2sec
TheClient->iWs.PrepareForSwitchOff();
TheClient->Flush();
User::After(2000000); //2sec
group1.SetOrdinalPosition(0);
group2.CancelTextCursor();
TheClient->Flush();
INFO_PRINTF1(_L(" Canceled Text Cursor "));
User::After(2000000); //2sec
//
// Before applying the fix, the following operations makes the Custom Text
// Cursor Sprite invisible (happens even without wserv heartbeat suppression)
INFO_PRINTF1(_L(" About to Set Text Cursor 2 "));
group1.SetOrdinalPosition(2);
group2.SetTextCursor(blank2,TPoint(20,20),tc);
TheClient->Flush();
INFO_PRINTF1(_L(" Set Text Cursor 2 "));
User::After(2000000); //2sec
TRawEvent event;
event.Set(TRawEvent::EActive);
TheClient->iWs.SimulateRawEvent(event);
TheClient->Flush();
INFO_PRINTF1(_L(" Simulated Active Event "));
User::After(2000000); //2sec
CleanupStack::PopAndDestroy(4, &group1);
INFO_PRINTF1(_L(" End of test "));
}
void CTCursorTest::CursorUpdatedBeforeWindowRenderedL()
{
INFO_PRINTF1(_L("CursorUpdatedBeforeWindowRenderedL"));
TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(0);
// We use some unique looking colors otherwise its harder
// to spot which test is which
TRgb kAqua(134, 242, 251);
iWorkInProgress = new(ELeave) CBlankWindow(kAqua);
iComparisonWindow = new(ELeave) CBlankWindow(kAqua);
CancelTextCursor();
const TSize screenSize=TheClient->iGroup->Size();
const TInt kPad = 5;
const TInt kThirdOfScreenWidth = screenSize.iWidth/3;
const TInt kWinWidth = kThirdOfScreenWidth - 2*kPad;
const TInt kWinHeight = screenSize.iHeight - 2*kPad;
const TSize kWinSize(kWinWidth, kWinHeight);
const TPoint kCursorPos(30, 30);
iComparisonWindow->SetUpL(TPoint(2*kThirdOfScreenWidth + kPad, kPad), kWinSize, TheClient->iGroup, *TheClient->iGc);
iWorkInProgress->SetUpL( TPoint( kThirdOfScreenWidth + kPad, kPad), kWinSize, TheClient->iGroup, *TheClient->iGc);
TTextCursor nonFlashingCursor;
nonFlashingCursor.iType = TTextCursor::ETypeRectangle;
nonFlashingCursor.iHeight=kCursorHeight;
nonFlashingCursor.iAscent=0;
nonFlashingCursor.iWidth=kCursorWidth;
nonFlashingCursor.iFlags=TTextCursor::EFlagNoFlash;
nonFlashingCursor.iColor = KRgbBlack;
TheClient->iGroup->GroupWin()->SetTextCursor(*iWorkInProgress->BaseWin(), kCursorPos, nonFlashingCursor);
// Up till this point, there has not been a CWsWindow::Render() for iWorkInProgress
// because the window has not been invalid
/*
* Here is the crux of the test. We want to create the following condition in a window group:
* 1) None of its windows have yet been Rendered using CWsWindow::Render()
* 2) A text cursor is present
* 3) Focus is lost then received
*
* It used to be the case that Wserv picked up the handle to the Render Stage Text Cursor
* drawer upon a Refresh caused by Rendering the window. But drawing the Text Cursor could
* come either from a Window Render or a change to the state of the Text Cursor, such as
* receiving focus in the window. A bug was experienced when the Text Cursor was drawn in
* a window which never had been rendered. This meant that the handle was not set up causing
* an assert.
*
* The code has been modified since then, to setup the handle to the Render Stage Text
* Cursor during Wserv initialisation. However, to guard against future changes, its
* worthwhile to have this corner case test to ensure it is possible to receive focus
* in a window which has never been rendered. That is because the text cursor state
* is updated in such circumstances, and that might trigger a draw of the cursor in a
* future version of the text cursor code.
*/
TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(1); // lose focus
TheClient->iWs.Finish();
TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(0); // gain focus
TheClient->iWs.Finish();
// If we get this far without a panic or assert, we have passed this test.
// Now allow CWsWindow::Render() to occur in iWorkInProgress
// The reason for doing this is so that when you watch the test
// progress you can see visual confirmation via the progress message and
// the coloured windows appear on the screen. Otherwise you would think
// that the test had either been skipped or had broken.
iWorkInProgress->Invalidate();
iWorkInProgress->Redraw();
iComparisonWindow->Invalidate();
iComparisonWindow->Redraw();
TheClient->iWs.Finish();
delete iWorkInProgress;
iWorkInProgress = NULL;
delete iComparisonWindow;
iComparisonWindow = NULL;
INFO_PRINTF1(_L("End of test"));
}
void CTCursorTest::INC097774()
{
TTimeIntervalMicroSeconds32 initialRepeatRate;
TTimeIntervalMicroSeconds32 repeatRate;
TheClient->iWs.GetKeyboardRepeatRate(initialRepeatRate,repeatRate);
//simulates a text cursor moving across the screen as if a user was holding down
//a key to scroll the cursor through a section of text.
//before applying the fix the cursor only shows up intermittently instead of smoothly
//scrolling across the screen.
const TSize cursorSize(3,20);
const TInt moveInterval=10;
SetCursor(TPoint(0,20),cursorSize,TRgb::Gray256(255),TTextCursor::EFlagNoFlash);
TheClient->Flush();
User::After(initialRepeatRate);
for(TInt offset=10;offset<=100;offset+=moveInterval)
{
SetCursor(TPoint(offset,20),cursorSize,TRgb::Gray256(255),TTextCursor::EFlagNoFlash);
TheClient->Flush();
User::After(repeatRate);
}
//simulate clipped text cursor moving accross the screen
TRect rect(0,20,3,40);
SetCursor(TPoint(0,20),cursorSize,TRgb::Gray256(255),rect,TTextCursor::EFlagNoFlash);
TheClient->Flush();
User::After(initialRepeatRate);
for(TInt offset=10;offset<=100;offset+=moveInterval)
{
rect.Move(moveInterval,0);
SetCursor(TPoint(offset,20),cursorSize,TRgb::Gray256(255),rect,TTextCursor::EFlagNoFlash);
TheClient->Flush();
User::After(repeatRate);
}
}
/** What happens when a cursor becomes off-screen when the screen is resized/rotated?
*
*
**/
void CTCursorTest::INC117232()
{
const TInt initialRepeatRate=300000; // 3/10 seconds should be long enough to update everything!
TInt currMode=TheClient->iScreen->CurrentScreenMode();
TInt testMode=currMode;
TPixelsTwipsAndRotation currModeSize;
TheClient->iScreen->GetScreenModeSizeAndRotation(currMode, currModeSize);
//find a (rotated) mode where the dimensions of the screen shrank
for (TInt mode=0;mode<TheClient->iScreenModes.Count();mode++)
{
TPixelsTwipsAndRotation testModeSize;
TheClient->iScreen->GetScreenModeSizeAndRotation(mode,testModeSize);
if ( testModeSize.iPixelSize.iWidth<currModeSize.iPixelSize.iWidth-10
|| testModeSize.iPixelSize.iHeight<currModeSize.iPixelSize.iHeight-10
)
{
testMode=mode;
break;
}
}
if (testMode==currMode)
{
_LIT(KLog,"No smaller screen-size modes available - INC117232 test skipped");
LOG_MESSAGE(KLog);
//iStep->SetTestStepResult(EInconclusive); //With this line the whole test fails which is too drastic
return;
}
//enable a cursor on the bottom right corner of the screen
TestWin->SetFullScreenExtL();
TheClient->Flush();
iCursorType=TTextCursor::ETypeRectangle;
SetCursor(TPoint(-20,-20)+TestWin->Size(),TSize(40,40),KRgbDarkMagenta,TTextCursor::EFlagNoFlash);
TheClient->Flush();
User::After(initialRepeatRate);
//shrink the screen
TheClient->iScreen->SetScreenMode(testMode);
TheClient->iScreen->SetAppScreenMode(testMode);
//The defect was that WServ would now crash!
TheClient->Flush();
User::After(initialRepeatRate);
//Set everything back
TheClient->iScreen->SetScreenMode(currMode);
TheClient->iScreen->SetAppScreenMode(currMode);
TheClient->Flush();
User::After(initialRepeatRate);
}
#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA
/**
* Sets up a text cursor whose attributes indicate it should not be flashing
* and then checks to ensure this is the actual behaviour.
*/
void CTCursorTest::TextCursorNoFlashTestL()
{
TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(0);
// We use some unique looking colors otherwise its harder
// to spot which test is which
TRgb kGentleYellow(251, 249, 198);
TRgb kGentlePink(253, 196, 221);
iWorkInProgress = new(ELeave) CBlankWindow(kGentleYellow);
iComparisonWindow = new(ELeave) CBlankWindow(kGentleYellow);
CancelTextCursor();
TheClient->Flush();
const TSize screenSize=TheClient->iGroup->Size();
const TInt kPad = 5;
const TInt kThirdOfScreenWidth = screenSize.iWidth/3;
const TInt kWinWidth = kThirdOfScreenWidth - 2*kPad;
const TInt kWinHeight = screenSize.iHeight - 2*kPad;
const TSize kWinSize(kWinWidth, kWinHeight);
const TPoint kCursorPos(30, 30);
iWorkInProgress->SetUpL( TPoint( kThirdOfScreenWidth + kPad, kPad), kWinSize, TheClient->iGroup, *TheClient->iGc);
iComparisonWindow->SetUpL(TPoint(2*kThirdOfScreenWidth + kPad, kPad), kWinSize, TheClient->iGroup, *TheClient->iGc);
TTextCursor nonFlashingCursor;
nonFlashingCursor.iType = TTextCursor::ETypeRectangle;
nonFlashingCursor.iHeight=kCursorHeight;
nonFlashingCursor.iAscent=0;
nonFlashingCursor.iWidth=kCursorWidth;
nonFlashingCursor.iFlags=TTextCursor::EFlagNoFlash;
nonFlashingCursor.iColor = kGentlePink; // We expect a Flicker Buffer Render Stage to ignore this color
iWorkInProgress->Invalidate();
iWorkInProgress->Redraw();
iComparisonWindow->Invalidate();
iComparisonWindow->Redraw();
DrawTextCursorSimilarToRenderStage(*TheClient->iGc, *iComparisonWindow->Win(), kCursorPos, nonFlashingCursor);
TheClient->iGroup->GroupWin()->SetTextCursor(*iWorkInProgress->BaseWin(), kCursorPos, nonFlashingCursor);
TheClient->Flush();
CheckCursorDoesNotFlash(iWorkInProgress->BaseWin()->Size());
delete iWorkInProgress;
iWorkInProgress = NULL;
delete iComparisonWindow;
iComparisonWindow = NULL;
}
void CTCursorTest::TextCursorFlashTestL()
{
TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(0);
// We use some unique looking colors otherwise its harder
// to spot which test is which
TRgb kMildPurple(218, 155, 244);
TRgb kPaleGreen(146, 190, 12);
iWorkInProgress = new(ELeave) CBlankWindow(kMildPurple);
iComparisonWindow = new(ELeave) CBlankWindow(kMildPurple);
CancelTextCursor();
TheClient->Flush();
const TSize screenSize=TheClient->iGroup->Size();
const TInt kPad = 5;
const TInt kThirdOfScreenWidth = screenSize.iWidth/3;
const TInt kWinWidth = kThirdOfScreenWidth - 2*kPad;
const TInt kWinHeight = screenSize.iHeight - 2*kPad;
const TSize kWinSize(kWinWidth, kWinHeight);
const TPoint kCursorPos(30, 30);
iWorkInProgress->SetUpL( TPoint( kThirdOfScreenWidth + kPad, kPad), kWinSize, TheClient->iGroup, *TheClient->iGc);
iComparisonWindow->SetUpL(TPoint(2*kThirdOfScreenWidth + kPad, kPad), kWinSize, TheClient->iGroup, *TheClient->iGc);
TTextCursor flashingCursor;
flashingCursor.iType = TTextCursor::ETypeRectangle;
flashingCursor.iHeight=kCursorHeight;
flashingCursor.iAscent=0;
flashingCursor.iWidth=kCursorWidth;
flashingCursor.iFlags=0; // implies that cursor SHOULD flash
flashingCursor.iColor = kPaleGreen; // We expect a Flicker Buffer Render Stage to ignore this color
iWorkInProgress->Invalidate();
iWorkInProgress->Redraw();
iComparisonWindow->Invalidate();
iComparisonWindow->Redraw();
DrawTextCursorSimilarToRenderStage(*TheClient->iGc, *iComparisonWindow->Win(), kCursorPos, flashingCursor);
TheClient->iGroup->GroupWin()->SetTextCursor(*iWorkInProgress->BaseWin(), kCursorPos, flashingCursor);
TheClient->Flush();
CheckCursorDoesFlash(kCursorPos, flashingCursor, kMildPurple);
CancelTextCursor();
TheClient->Flush();
delete iWorkInProgress;
iWorkInProgress = NULL;
delete iComparisonWindow;
iComparisonWindow = NULL;
}
void CTCursorTest::DrawTextCursorSimilarToRenderStage(CWindowGc& aGc, RWindow& aWin, const TPoint& aPos, const TTextCursor& aTextCursor)
{
// This method duplicates the way in which the default FlickerBuffer Render
// Stage draws a Text Cursor of ETypeRectangle. @see CFbRenderStage::DrawTextCursor
// This code must be kept in sync with the FlickerBuffer Render Stage
ASSERT(aTextCursor.iType == TTextCursor::ETypeRectangle);
const TRect updatedRegion(aPos,TSize(aTextCursor.iWidth,aTextCursor.iHeight));
aWin.Invalidate();
aWin.BeginRedraw();
aGc.Activate(aWin);
aGc.Clear();
aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
aGc.SetBrushColor(KRgbBlack);
aGc.SetPenStyle(CGraphicsContext::ENullPen);
aGc.Clear(updatedRegion);
aGc.Deactivate();
aWin.EndRedraw();
}
void CTCursorTest::CheckCursorDoesNotFlash(const TSize& aSize)
{
const TInt kSampleTime = 100000; // one tenth of a second
const TInt kSampleLimit = 100;
TInt sampleIteration = 0;
TBool comparisonOkay = EFalse;
while (sampleIteration < kSampleLimit)
{
comparisonOkay = DoCheckRect(iWorkInProgress, iComparisonWindow, TRect(TPoint(), aSize), CWsScreenDevice::EIncludeTextCursor);
if (!comparisonOkay)
{
INFO_PRINTF2(_L("CheckCursorDoesNotFlash difference found after %d milliseconds"), sampleIteration*100);
break;
}
sampleIteration++;
User::After(kSampleTime);
}
TEST(comparisonOkay);
}
void CTCursorTest::UpdateCountersOnCursorTransition(
const TBool aTransitionedToOn,
TTime& aNow,
TInt64& aDeltaTime,
TTime& aLastDeltaTime,
TInt& aWarmUpIterations,
const TInt& aFlashChangeTime,
const TInt& aToleranceMargin,
TInt& aSampleNumber,
TInt& aToleranceViolations
)
{
_LIT(KTxtOn, " On");
_LIT(KTxtOff, "Off");
TBufC<3> transitionType;
transitionType = aTransitionedToOn ? KTxtOn : KTxtOff;
aNow.UniversalTime();
aDeltaTime = aNow.MicroSecondsFrom(aLastDeltaTime).Int64();
aLastDeltaTime = aNow;
if (aWarmUpIterations > 0)
{
aWarmUpIterations--;
}
else
{
if (aDeltaTime > aFlashChangeTime + aToleranceMargin ||
aDeltaTime < aFlashChangeTime - aToleranceMargin)
{
INFO_PRINTF5(_L(" Iteration %d, Cursor %S after %d, errorDelta %d microseconds"),
aSampleNumber, &transitionType, I64INT(aDeltaTime), I64INT(aDeltaTime - aFlashChangeTime));
aToleranceViolations++;
}
}
}
void CTCursorTest::CheckCursorDoesFlash(const TPoint& aPos, const TTextCursor& aTextCursor, TRgb /* aBackgroundColor */)
{
/**
* Quality of Service based thresholding
*
* The idea behind this test is to identify tolerances which would either
* cause the test to fail when the user would perceive the text cursor as
* not flashing uniformly, or would point to an unexpected delay outside
* the way the flashing (and scheduling of animations) is supposed to work.
*
* Potentially the cursor can be late if we miss a V-SYNC from hardware. In
* such cases we expect to see the cursor on the next frame. Since the V-SYNC
* is typically 1/50 second, a tolerance of two frames, or 1/25 second is reasonable.
*
* If the cursor is delayed longer than this, say a long time of 1 second, but this
* does not happen too often, then the user is likely to still be happy. So we
* set the period of testing to 60 seconds, and set the violations limit to 2.
*/
const TInt kOneSecond = 1000000;
const TInt kFlashPeriod = kOneSecond; // comprises one "ON" and one "OFF"
const TInt kToleranceFactor = 25; // meaning 1/25 of a Flash Period
const TInt kNumberTestFlashPeriods = 60; // meaning 60 Flash Periods worth of testing
const TInt kMaximumToleranceViolations = 2; // number of times an occassional flash may be late or early
const TInt kToleranceMargin = kFlashPeriod / kToleranceFactor;
const TInt kNumberSamples = kNumberTestFlashPeriods * kToleranceFactor;
const TInt kFlashChangeTime = kFlashPeriod / 2;
// The first couple of changes to the cursor should be ignored because
// when the test is started, the cursor may have been on for a while.
// Then when the cursor goes off, it appears to have switched to the
// off state too early. We therefore ignore the first two changes
// so we start cleanly.
TInt warmUpIterations = 2;
// Empirically we see that cursors mostly flash with good timeliness apart from
// occasional events causing them to be either early or late. In order to keep
// a tight tolerance (1/50 second is around the screen refresh time) but still
// allow for the occasional variance (seen to be 1/23 second) we use a counter
// toleranceViolations < kMaximumToleranceViolations
TInt toleranceViolations = 0;
TBool cursorShownLastTime = EFalse;
TBool cursorShown = EFalse;
TTime lastDeltaTime;
TTime now;
TInt64 deltaTime = 0;
lastDeltaTime.UniversalTime();
now.UniversalTime();
TRect textCursorRect(TRect(aPos, TSize(aTextCursor.iWidth, aTextCursor.iHeight)));
for (TInt sampleNumber = 0; sampleNumber < kNumberSamples; sampleNumber++)
{
cursorShown = DoCheckRect(iWorkInProgress, iComparisonWindow, textCursorRect, CWsScreenDevice::EIncludeTextCursor);
if (cursorShown && !cursorShownLastTime)
{
cursorShownLastTime = ETrue;
UpdateCountersOnCursorTransition(
cursorShownLastTime, now, deltaTime, lastDeltaTime, warmUpIterations, kFlashChangeTime,
kToleranceMargin, sampleNumber, toleranceViolations);
}
else if (!cursorShown && cursorShownLastTime)
{
cursorShownLastTime = EFalse;
UpdateCountersOnCursorTransition(
cursorShownLastTime, now, deltaTime, lastDeltaTime, warmUpIterations, kFlashChangeTime,
kToleranceMargin, sampleNumber, toleranceViolations);
}
if (toleranceViolations > kMaximumToleranceViolations)
break;
User::After(kToleranceMargin);
}
// Check was some flashing
TEST_SOFTFAIL_WINSCW(warmUpIterations == 0);
// Check cursor flashed on and off, regularly and on-time
TEST_SOFTFAIL_WINSCW(toleranceViolations <= kMaximumToleranceViolations);
}
#endif // TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA
void CTCursorTest::MakeCursors(TTextCursor& aTextCursor, TTextCursor& aCustomCursor)
{
aCustomCursor.iType = KTextCursorInitialIdValue + iTest->iScreenNumber*KNumberOfCustoTextCursors; // custom text cursor
aCustomCursor.iAscent=0;
aCustomCursor.iHeight=kCursorHeight;
aCustomCursor.iWidth=kCursorWidth;
aCustomCursor.iFlags=TTextCursor::EFlagNoFlash;
aCustomCursor.iColor=TRgb::Color256(217);
// Create a standard cursor for the tests
aTextCursor.iType = TTextCursor::ETypeRectangle; // Normal rectangular text cursor
aTextCursor.iHeight=kCursorHeight;
aTextCursor.iAscent=0;
aTextCursor.iWidth=kCursorWidth;
aTextCursor.iFlags=TTextCursor::EFlagNoFlash;
}
void CTCursorTest::StartDoubleCursorTestL(TInt aTestNumber)
{
// general setup
CBlankWindow* win1=new(ELeave) CBlankWindow(KRgbWhite);
CleanupStack::PushL(win1);
win1->SetUpL(kWin1TopLeft,kWinSize,TheClient->iGroup,*TheClient->iGc,EColor64K);
win1->Redraw();
// Create the second window
CBlankWindow* win2=new(ELeave) CBlankWindow(KRgbWhite);
CleanupStack::PushL(win2);
win2->SetUpL(kWin2TopLeft,kWinSize,TheClient->iGroup,*TheClient->iGc,EColor64K);
win2->Redraw();
// Create normal and custom cursor for the tests
TTextCursor textCursor;
TTextCursor customCursor;
MakeCursors(textCursor, customCursor);
TheClient->Flush();
CWindowGc* winGc = TheClient->iGc;
switch(aTestNumber)
{
case 1:
CheckNoDoubleCursorTest1L(win1, win2, textCursor, customCursor, winGc);
break;
case 2:
CheckNoDoubleCursorTest2L(win1, win2, textCursor, customCursor, winGc);
break;
case 3:
CheckNoDoubleCursorTest3L(win1, win2, textCursor, customCursor, winGc);
break;
default:
TEST(EFalse);
break;
}
CleanupStack::PopAndDestroy(2);
}
// DEF098704
void CTCursorTest::CheckNoDoubleCursorTest1L(CBlankWindow* aWin1, CBlankWindow* aWin2, TTextCursor& /*aTextCursor*/, TTextCursor& aCustomCursor, CWindowGc* aWinGc)
{
// Test that changing the focus of a custom text cursor does not leave that cursor drawn where it was (INC093898)
TheClient->iGroup->GroupWin()->SetTextCursor(*aWin1->BaseWin(),TPoint(),aCustomCursor);
// Bit blit the TEST_BITMAP_NAME image to the second window to use as a comparison
// this is the same image that the custom cursor is using
CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;
CleanupStack::PushL(bitmap);
TEST(KErrNone == bitmap->Load(TEST_BITMAP_NAME,0,ETrue));
aWinGc->Activate(*aWin2->Win());
TRect updateArea(TPoint(0,0), bitmap->SizeInPixels());
aWin2->Win()->Invalidate(updateArea);
aWin2->Win()->BeginRedraw(updateArea);
aWinGc->BitBlt(TPoint(0,0),bitmap);
aWinGc->Deactivate();
aWin2->Win()->EndRedraw();
TheClient->Flush();
doCheckNoDoubleCursor(aWin1,aWin2,kWin1TopLeft,kWin2TopLeft,aCustomCursor,bitmap->SizeInPixels(),CWsScreenDevice::EIncludeSprite);
CleanupStack::PopAndDestroy(1); // bitmap
}
// DEF098704
void CTCursorTest::CheckNoDoubleCursorTest2L(CBlankWindow* aWin1, CBlankWindow* aWin2, TTextCursor& /*aTextCursor*/, TTextCursor& aCustomCursor, CWindowGc* aWinGc)
{
//TEST 2: Checks that no artifacts are left behind when a text cursor is moved from under a transparent sprite
// Construct the window win1 with a transparent sprite
// Clear the top and bottom windows
ResetWindows(aWinGc,aWin1,aWin2);
// Create a bitmap and a corresponding bitmap mask
CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;
CleanupStack::PushL(bitmap);
TEST(KErrNone == bitmap->Load(TEST_BITMAP_NAME,0,ETrue));
CBitmap* spriteBitmap=CBitmap::NewL(kWinSize,EColor256);
CleanupStack::PushL(spriteBitmap);
spriteBitmap->Gc().SetBrushColor(KRgbBlack);
spriteBitmap->Gc().SetBrushStyle(CGraphicsContext::ESolidBrush);
spriteBitmap->Gc().SetPenStyle(CGraphicsContext::ESolidPen);
spriteBitmap->Gc().DrawRect(TRect(kWinSize));
CBitmap* mask=CBitmap::NewL(kWinSize,EColor256);
CleanupStack::PushL(mask);
mask->Gc().SetBrushStyle(CGraphicsContext::ESolidBrush);
mask->Gc().SetBrushColor(KRgbBlack);
mask->Gc().DrawRect(TRect(kWinSize));
// Create a sprite
RWsSprite sprite = RWsSprite(TheClient->iWs);
CleanupClosePushL(sprite);
TEST(KErrNone == sprite.Construct(*aWin1->BaseWin(),TPoint(),0));
// Add the bitmap to the sprite
TSpriteMember member;
member.iInvertMask=EFalse;
member.iDrawMode=CGraphicsContext::EDrawModePEN;
member.iOffset=TPoint();
member.iInterval=TTimeIntervalMicroSeconds32(0);
member.iBitmap = &spriteBitmap->Bitmap();
member.iMaskBitmap = &mask->Bitmap();
TEST(KErrNone == sprite.AppendMember(member));
// Activate the sprite in win1
TEST(KErrNone == sprite.Activate());
// Put a cursor in win1
TheClient->iGroup->GroupWin()->SetTextCursor(*aWin1->BaseWin(),TPoint(),aCustomCursor);
// Bit blit the matching bitmap to the bottom window
TRect bitmapArea(TPoint(0,0), bitmap->SizeInPixels());
aWin2->Win()->Invalidate(bitmapArea);
aWin2->Win()->BeginRedraw(bitmapArea);
aWinGc->Activate(*aWin2->Win());
aWinGc->BitBlt(TPoint(),bitmap);
aWinGc->Deactivate();
aWin2->Win()->EndRedraw();
TheClient->Flush();
doCheckNoDoubleCursor(aWin1,aWin2,kWin1TopLeft,kWin2TopLeft,aCustomCursor,bitmap->SizeInPixels(),CWsScreenDevice::EIncludeSprite);
CleanupStack::PopAndDestroy(4); // sprite, mask, spriteBitmap, bitmap
}
// DEF098704
void CTCursorTest::CheckNoDoubleCursorTest3L(CBlankWindow* aWin1, CBlankWindow* aWin2, TTextCursor& aTextCursor,TTextCursor& aCustomCursor, CWindowGc* aWinGc)
{
//
// TEST 3: Test a flashing text cursor does not leave artifacts when a redraw + change position happens during
// the time the cursor flashing 'off'
//
// This test moves a flashing cursor a number of times over a two second period to a seconds position.
// it does it a number of times so some of the redraws will occur during the 'flash off' period
// We then compare the 'after' position to what we expect
//
// There are four possible outcomes when we look at the bitmap after the redraw + move
// Position 1 is the original position, position 2 is the new position after the redraw
//
// cursor artifact @ pos1 and flashed on cursor @ pos2
// cursor artifact at pos1 and flashed off cursor @ pos2
// no artifact at pos1 and flashed off cursor @ pos2
// no artifact at pos1 and flashed on cursor @ pos2
//
// any artifacts left over will cause the complete test to fail.
//
//
// PART A:
aTextCursor.iFlags=0; // flashing
ResetWindows(aWinGc,aWin1,aWin2);
TestForArtifacts(aWin1, aTextCursor);
//
// PART B - For a non-custom text cursor
aCustomCursor.iFlags=0; // flashing
ResetWindows(aWinGc,aWin1,aWin2);
TestForArtifacts(aWin1, aCustomCursor);
}
// moves the cursor between two positions while flashing and tests no artifacts are left at the position it moved from
// The moves take place in a loop so it is tested happening when the cursor is flashed on and also off
void CTCursorTest::TestForArtifacts(CBlankWindow* aWin1, TTextCursor& aCursor)
{
const TInt KIterations = 30;
const TPoint kStartPos(0,0);
const TPoint kMoveToPos(200,0);
TRect r1(kWin1TopLeft,kCursorSize);
TRect r2(kWin2TopLeft,kCursorSize);
const TPoint kWin1TopLeft;
const TPoint kWin2TopLeft;
const TSize aCursorSize;
TheClient->iGroup->GroupWin()->SetTextCursor(*aWin1->BaseWin(),kStartPos,aCursor);
TheClient->Flush();
TInt initialRepeatRate = 1000000;
const TInt KIncrement = 30000;
TInt i=0;
for(i=0; i<KIterations; i++)
{
// move the cursor to its new position
TheClient->iGroup->GroupWin()->SetTextCursor(*aWin1->BaseWin(),kMoveToPos,aCursor);
TheClient->Flush();
User::After(initialRepeatRate);
// check no artifact was left in position 1 by comparing against (blank) win2
if(!TheClient->iScreen->RectCompare( r1,r2, CWsScreenDevice::EIncludeTextCursor))
{
break; // detected an artifact remaining, test failed
}
// move the cursor back to its start position, this resets the flash timer which is why we increment initialRepeatRate
TheClient->iGroup->GroupWin()->SetTextCursor(*aWin1->BaseWin(),kStartPos,aCursor);
TheClient->Flush();
initialRepeatRate += KIncrement;
}
// if all went well i should equal KIterations, if it doesnt its because we detected
// an artifact and quit the test early
TEST_SOFTFAIL_WINSCW(i==KIterations);
}
// Tests the two windows match, moves the cursor off win 1 then tests they no longer match
void CTCursorTest::doCheckNoDoubleCursor(CBlankWindow* aWin1,
CBlankWindow* aWin2,
const TPoint& aWin1Tl,
const TPoint& aWin2Tl,
const TTextCursor& aCursor,
const TSize& aCursorSize,
CWsScreenDevice::TSpriteInCompare aFlags)
{
TRect r1(aWin1Tl,aCursorSize);
TRect r2(aWin2Tl,aCursorSize);
TInt compareTries = 0;
const TInt compareLimit = 5;
TBool correctComparison = EFalse;
while (!correctComparison && compareTries < compareLimit)
{
compareTries++;
User::After(500000);
correctComparison = TheClient->iScreen->RectCompare(r1,r2, aFlags);
}
INFO_PRINTF3(_L("Result Before %d (attempts %d)"), correctComparison, compareTries);
TEST_SOFTFAIL_WINSCW(correctComparison);
// Change the focus off win1, by drawing the text cursor on the second window
TheClient->iGroup->GroupWin()->SetTextCursor(*aWin2->BaseWin(),aWin2Tl,aCursor);
TheClient->Flush();
// Cause a redraw
aWin1->CTWin::DrawNow();
TheClient->WaitForRedrawsToFinish();
// make sure any cursor has actually moved
User::After(1000000); // 1 sec
TBool resultAfter;
resultAfter = !TheClient->iScreen->RectCompare(r1,r2, aFlags);
INFO_PRINTF2(_L("Result After %d"), resultAfter);
TEST_SOFTFAIL_WINSCW(resultAfter);
}
// resets the windows to their initial state
void CTCursorTest::ResetWindows(CWindowGc* aWinGc,CBlankWindow* aWin1,CBlankWindow* aWin2)
{
TheClient->iGroup->GroupWin()->CancelTextCursor();
aWinGc->Activate(*aWin1->Win());
aWinGc->Reset();
aWinGc->Clear();
aWinGc->Deactivate();
aWin1->Invalidate();
aWin1->Redraw();
aWin2->Invalidate();
aWin2->Redraw();
TheClient->Flush();
}
void CTCursorTest::RunTestCaseL(TInt /*aCurTestCase*/)
{
TBool deleteMove=EFalse;
((CTCursorTestStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
switch(++iTest->iState)
{
/**
@SYMTestCaseID GRAPHICS-WSERV-0241
@SYMDEF DEF081259
@SYMTestCaseDesc Test the text cursor functions properly as a window is moved
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Move a window about the screen and meanwhile check the text
cursor functions correctly
@SYMTestExpectedResults The text cursor functions correctly as the window is moved
*/
case 1:
((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0241"));
while (!deleteMove)
{
if (iCursorType==TTextCursor::ETypeFirst)
iTest->LogSubTest(_L("Cursor 1"));
if (MoveWindow())
{
if (IncrementCursorType())
{
ResetMoveWindowsL();
}
else
{
DeleteMoveWindows();
deleteMove =true;
}
}
}
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0242
@SYMDEF DEF081259
@SYMTestCaseDesc Test the text cursor functions properly as the window is scrolled
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Scroll the window and meanwhile check the text cursor functions correctly
@SYMTestExpectedResults The text cursor functions correctly as the window is scrolled
*/
case 2:
((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0242"));
iTest->LogSubTest(_L("Cursor 2"));
iCursorType=TTextCursor::ETypeRectangle;
ScrollTest();
iCursorType=TTextCursor::ETypeFirst;
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0244
@SYMDEF DEF081259
@SYMTestCaseDesc Test the text cursor functions properly as a blank window is moved
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Move a blank window about the screen and meanwhile check the text
cursor functions correctly
@SYMTestExpectedResults The text cursor functions correctly as the blank window is moved
*/
case 3:
((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0244"));
iTest->LogSubTest(_L("Move window1"));
MoveWindowTest1L();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0245
@SYMDEF DEF081259
@SYMTestCaseDesc Test that a non flashing text cursor functions properly as a
blank window is moved
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Move a blank window about the screen and meanwhile check that a non
flashing text cursor functions correctly
@SYMTestExpectedResults The text cursor functions correctly as the blank window is moved
*/
case 4:
((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0245"));
while (IncrementCursorType())
{
iTest->LogSubTest(_L("Move window2"));
MoveWindowTest2L();
}
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0247
@SYMDEF DEF081259
@SYMTestCaseDesc Tests a Custom Text Cursor Sprite visibility after wserv hearbeat suppression
REQUIREMENT: INC040489.
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Create a window group with an associated window for it, then activate it.
Create another window group with an associated window along with a custom cursor,
then active it. Make a call to suppress the wserv hearbeat, which will stop
the custom cursor from flashing with flash ON state. Bring the first window
group to the foreground and cancel the custom test cursor in the second window group.
After that, put the first window group to the background and set the custom test
cursor in the second window group. Simulate a raw key event to start
the wserv heartbeat, which will make the custom cursor flashing.
@SYMTestExpectedResults The Custom text cursor in the second window group should be visible and flashing,
when it comes to the foreground after the first window group sent to the background.
*/
case 5:
((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0247"));
iTest->LogSubTest(_L("Custom Text Cursor Sprite visibility"));
INC040489L();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-2095-0015
@SYMTestCaseDesc Text Cursor allows Update before Rendering the owning window
@SYMTestPriority Normal
@SYMTestStatus Implemented
@SYMTestActions Create a window group and two windows, one with a Text Cursor.
Stimulate a state change in the Text Cursor by receiving
window focus, but before the Window has ever been Rendered.
This shakes out logic in RWsTextCursor which depends on
side effects arising from having executed CWsWindow::Render()
@SYMTestExpectedResults
There should be no panic or assertion.
*/
case 6:
((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-2095-0015"));
iTest->LogSubTest(_L("Update before Render"));
CursorUpdatedBeforeWindowRenderedL();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0248
@SYMDEF DEF081259
@SYMTestCaseDesc Tests a bad use of text cursor functionality from a client.
REQ 1079, CR RDEF-5F7Q24 (10/04/2003).
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions This test case checks whether the window server is able to detect a bad
use of the text cursor functionality (including the custom text cursor)
by a client.
This test case launches several threads and each of them will try
to use the text cursor functionality in a non-proper way.
@SYMTestExpectedResults Each new thread has panic code associated to it. This is the expected panic when
the thread dies.
The thread once launched is expected to panic and the returning panic code should
match the expected one.
*/
case 7:
((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0248"));
iTest->LogSubTest(_L("Panic"));
TestPanicsL();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0400
@SYMDEF PDEF099013
@SYMTestCaseDesc Cursor moves slowly in text editors.
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions This test case is a VISUAL TEST only on whether a scrolling text cursor is drawn to the
screen correctly. 2 types of cursor are checked both clipped and non clipped cursors.
In each case the test simulates a text cursor moving across the screen as if a user were
holding down a key to scroll the cursor through a section of text.
@SYMTestExpectedResults The text cursor in both cases should scroll smoothly to the centre of the screen.
In versions prior to this fix the cursor was not correctly drawn and appeared to move
slowly.
*/
case 8:
((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0400"));
iTest->LogSubTest(_L("Text Cursor Update Tests"));
INC097774();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0401
@SYMDEF DEF098704
@SYMTestCaseDesc Test code for implemented fix to remove double cursors
@SYMTestPriority Normal
@SYMTestStatus Implemented
@SYMTestActions This test case tests for artifacts left over when normal/custon flashing/non-flashing cursors are drawn.
Test that changing the focus of a custom text cursor does not leave that cursor drawn where it was (INC093898)
@SYMTestExpectedResults
*/
case 9:
((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0401"));
iTest->LogSubTest(_L("Double cursors test 1"));
StartDoubleCursorTestL(1);
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0402
@SYMDEF DEF098704
@SYMTestCaseDesc Test code for implemented fix to remove double cursors
@SYMTestPriority Normal
@SYMTestStatus Implemented
@SYMTestActions Checks that no artifacts are left behind when a text cursor is moved from under a transparent sprite
@SYMTestExpectedResults
*/
case 10:
((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0402"));
iTest->LogSubTest(_L("Double cursors test 2"));
StartDoubleCursorTestL(2);
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0403
@SYMDEF DEF098704
@SYMTestCaseDesc Test code for implemented fix to remove double cursors
@SYMTestPriority Normal
@SYMTestStatus Implemented
@SYMTestActions This test moves a flashing cursor a number of times over a two second period to a seconds position.
it does it a number of times so some of the redraws will occur during the 'flash off' period
We then compare the 'after' position to what we expect
@SYMTestExpectedResults
*/
case 11:
((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0403"));
iTest->LogSubTest(_L("Double cursors test 3"));
StartDoubleCursorTestL(3);
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0483
@SYMDEF INC117232
@SYMTestCaseDesc Test code: Refreshing cursors becoming offscreen due to screen size change should not panic
@SYMTestPriority Normal
@SYMTestStatus Implemented
@SYMTestActions Create a cursor on bottom right of screen, change to a screen mode that excludes that coordinate
@SYMTestExpectedResults
The server should not panic.
*/
case 12:
((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0483"));
iTest->LogSubTest(_L("Screen resize invalidate cursor off-screen"));
INC117232();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-2095-0016
@SYMTestCaseDesc Text Cursor flag TTextCursor::EFlagNoFlash honored
@SYMTestPriority Normal
@SYMTestStatus Implemented
@SYMTestActions Create a text cursor with the TTextCursor::EFlagNoFlash setting. Observe the screen over
a short period of time to verify that it remains continuously in the Flash ON state.
@SYMTestExpectedResults
The text cursor should be always shown.
*/
case 13:
#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA
((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-2095-0016"));
iTest->LogSubTest(_L("Text cursor EFlagNoFlash test"));
TextCursorNoFlashTestL();
#endif
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-2095-0009
@SYMTestCaseDesc Text Cursor flashes when flag value is 0
@SYMTestPriority Normal
@SYMTestStatus Implemented
@SYMTestActions Create a text cursor with the 0 flag setting. Observe the screen over
a short period of time to verify that the cursor flashes ON and OFF at
the correct period of one second.
@SYMTestExpectedResults
The text cursor should flash.
*/
case 14:
#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA
((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-2095-0009"));
iTest->LogSubTest(_L("Text cursor will Flash test"));
TextCursorFlashTestL();
#endif
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-2095-0017
@SYMTestCaseDesc Text Cursor handles different valid Cursor Setttings
@SYMTestPriority Normal
@SYMTestStatus Implemented
@SYMTestActions Create a text cursor and then issue a SetTextCursor. Then repeatedly
call SetTextCursor, varying the arguments relating to the Text Cursor
as well as keeping the arguments the same on one occassion.
@SYMTestExpectedResults
The system should not panic as the arguments supplied are never invalid.
*/
case 15:
((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-2095-0017"));
iTest->LogSubTest(_L("SetTextCursor test"));
TextCursorSetLCoverageTests();
break;
default:
((CTCursorTestStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
((CTCursorTestStep*)iStep)->CloseTMSGraphicsStep();
TestComplete();
break;
}
((CTCursorTestStep*)iStep)->RecordTestResultL();
}
__WS_CONSTRUCT_STEP__(CursorTest)