// 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:
// Client side of AUTODLL test code
//
//
/**
@file
@test
@internalComponent - Internal Symbian test code
*/
#include "TAUTODLL.H"
#include "TEVENT.H"
//#define LOGGING
//
CGraphicsContext::TDrawMode CAnimWindow::iEllipseDrawMode;
CTAnimDll::CTAnimDll(CTestStep* aStep) : CTWsGraphicsBase(aStep)
{
}
RTestAnim::RTestAnim() : RAnim()
{
}
RTestAnim::RTestAnim(RAnimDll &aDll) : RAnim(aDll)
{
}
LOCAL_C TInt DoPanicTest(TInt aInt, TAny *aScreenNumber)
{
RWsSession ws;
User::LeaveIfError(ws.Connect());
// assign to the correct screen
CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws);
User::LeaveIfError(screen->Construct((TInt)aScreenNumber));
RWindowGroup group(ws);
User::LeaveIfError(group.Construct(333));
group.EnableReceiptOfFocus(EFalse); // Stop auto group switching on close
RAnimDll animDll=RAnimDll(ws);
User::LeaveIfError(animDll.Load(KAnimDLLName));
RTestAnim panic(animDll);
RWindow window(ws);
RBlankWindow blankwin(ws);
if (aInt==16 || aInt==17) // Use a blank window for this one
{
User::LeaveIfError(blankwin.Construct(group,123));
blankwin.SetSize(TSize(10,10));
blankwin.Activate();
User::LeaveIfError(panic.Construct(blankwin,EAnimTypeTest1,TPtrC8()));
}
else
{
User::LeaveIfError(window.Construct(group,123));
window.SetSize(TSize(10,10));
window.Activate();
window.BeginRedraw();
window.EndRedraw();
if (aInt==0)
User::LeaveIfError(panic.Construct(window,EAnimTypeTest2,TPtrC8()));
User::LeaveIfError(panic.Construct(window,EAnimTypeTest1,TPtrC8()));
}
TPckgBuf<TPoint> dummyParam;
switch(aInt)
{
case 1:
panic.Command(EADllPanicCallPanic);
break;
case 2:
panic.Command(EADllPanicCallPanic,dummyParam);
break;
case 3:
panic.CommandReply(EADllPanicCallPanic);
break;
case 4:
panic.CommandReply(EADllPanicCallPanic,dummyParam);
break;
case 5:
panic.Command(EADllPanicSetInterval);
break;
case 6:
panic.Command(EADllPanicSetNextInterval);
break;
case 7:
panic.CommandReply(EADllPanicBadFont);
break;
case 8:
panic.CommandReply(EADllPanicBadBitmap);
break;
case 9:
panic.Command(EADllPanicLeave);
break;
case 10:
panic.Command(EADllPanicDoubleActivateGC);
break;
case 11:
panic.Command(EADllPanicDrawRectWithNoGc);
break;
case 12:
panic.Command(EADllPanicDrawTextWithNoFont);
break;
case 13:
panic.Command(EADllPanicLeaveInAnimate);
ws.Finish();
panic.CommandReply(EADllBlankOpCode);
break;
case 14:
panic.Command(EADllPanicLeaveInRedraw);
window.BeginRedraw();
window.EndRedraw();
ws.Finish();
panic.CommandReply(EADllBlankOpCode);
break;
case 15:
ws.TestWrite(animDll.WsHandle(),999,NULL,0);
break;
case 16:
panic.Command(EADllPanicSetVisWithGcActive);
break;
case 17:
panic.CommandReply(EADllPanicSetVisWithGcActiveReply);
break;
case 18:
panic.Command(EADllPanicLeaveInActiveCallback);
ws.Flush();
User::After(2000000);
panic.CommandReply(EADllBlankOpCode);
break;
case 19:
panic.Command(EADllPanicSetClippingRectWithNoGc);
break;
case 20:
panic.CommandReply(EADllPanicSetClippingRegionWithNoGc);
break;
case 21:
panic.Command(EADllPanicCancelClippingRegionWithNoGc);
break;
case 22:
panic.Command(EADllPanicCancelClippingRectWithNoGc);
break;
case 23:
panic.Command(EADllPanicSetDrawModeWithNoGc);
break;
case 24:
panic.Command(EADllPanicUseFontWithNoGc);
break;
case 25:
panic.Command(EADllPanicDiscardFontWithNoGc);
break;
case 26:
panic.Command(EADllPanicSetUnderlineStyleWithNoGc);
break;
case 27:
panic.Command(EADllPanicSetStrikeThoughStyleWithNoGc);
break;
case 28:
panic.Command(EADllPanicSetWordJustificationWithNoGc);
break;
case 29:
panic.Command(EADllPanicSetCharJustificationWithNoGc);
break;
case 30:
panic.Command(EADllPanicSetPenColorWithNoGc);
break;
case 31:
panic.Command(EADllPanicSetPenStyleWithNoGc);
break;
case 32:
panic.Command(EADllPanicSetPenSizeWithNoGc);
break;
case 33:
panic.Command(EADllPanicSetBrushColorWithNoGc);
break;
case 34:
panic.Command(EADllPanicSetBrushStyleWithNoGc);
break;
case 35:
panic.Command(EADllPanicSetBrushOriginWithNoGc);
break;
case 36:
panic.Command(EADllPanicUseBrushPatterWithNoGc);
break;
case 37:
panic.Command(EADllPanicDiscardBrushPatternWithNoGc);
break;
case 38:
panic.Command(EADllPanicSetFadedWithNoGc);
break;
case 39:
panic.Command(EADllPanicSetFadingParametersWithNoGc);
break;
case 40:
panic.Command(EADllPanicDrawArcWithNoGc);
break;
case 41:
panic.Command(EADllPanicDrawPieWithNoGc);
break;
case 42:
panic.Command(EADllPanicDrawLineWithNoGc);
break;
case 43:
panic.Command(EADllPanicDrawLineToWithNoGc);
break;
case 44:
panic.Command(EADllPanicDrawLineByWithNoGc);
break;
case 45:
panic.Command(EADllPanicDrawEllipseWithNoGc);
break;
case 46:
panic.Command(EADllPanicDrawRoundedRecWithNoGc);
break;
case 47:
panic.Command(EADllPanicClearWithRectWithNoGc);
break;
case 48:
panic.Command(EADllPanicClearWithNoGc);
break;
case 49:
panic.Command(EADllPanicBitBltWithNoGc);
break;
case 50:
panic.Command(EADllPanicBitBltWithRectWithNoGc);
break;
case 51:
panic.Command(EADllPanicBitBltMaskedWithNoGc);
break;
case 52:
panic.Command(EADllPanicDrawBitmapPointWithNoGc);
break;
case 53:
panic.Command(EADllPanicDrawBitmapWithNoGc);
break;
case 54:
panic.Command(EADllPanicDrawBitmapRectWithNoGc);
break;
case 55:
panic.Command(EADllPanicDrawBitmapMaskedFbsBitmapWithNoGc);
break;
case 56:
panic.Command(EADllPanicDrawBitmapMaskedWsBitmapWithNoGc);
break;
case 57:
panic.Command(EADllPanicDrawPolyLinePointsWithNoGc);
break;
case 58:
panic.Command(EADllPanicDrawPolyLineArrayWithNoGc);
break;
case 59:
panic.CommandReply(EADllPanicDrawPolygonPointsWithNoGc);
break;
case 60:
panic.CommandReply(EADllPanicDrawPolygonArrayWithNoGc);
break;
case 61:
panic.Command(EADllPanicMoveToWithNoGc);
break;
case 62:
panic.Command(EADllPanicMoveByWithNoGc);
break;
case 63:
panic.Command(EADllPanicPlotWithNoGc);
break;
case 64:
panic.Command(EADllPanicSetOriginWithNoGc);
break;
case 65:
panic.Command(EADllPanicCopyRectWithNoGc);
break;
case 66:
panic.Command(EADllPanicResetWithNoGc);
break;
case 67:
panic.CommandReply(EADllPanicAlphaBlendingBitmapsFbsBitmapWithNoGc);
break;
case 68:
panic.Command(EADllPanicMapColorsWithNoGc);
break;
case 69:
panic.Command(EADllPanicDrawTextWithRectWithNoFont);
break;
case 70:
panic.Command(EADllPanicDrawTextVerticalWithNoFont);
break;
case 71:
panic.Command(EADllPanicDrawTextVerticalWithRectWithNoFont);
break;
case 72:
panic.CommandReply(EADllPanicDevice);
break;
case 73:
panic.Command(EADllPanicInvalidFocusScreenTooBig);
break;
case 74:
panic.Command(EADllPanicInvalidFocusScreenNegative);
break;
default:
return(EWsExitReasonFinished);
}
ws.Flush();
return(EWsExitReasonBad);
}
/**
@SYMTestCaseID GRAPHICS-WSERV-0125
@SYMDEF DEF081259
@SYMTestCaseDesc Panic tests
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions The test creates an animation and animation's client threads.
Each thread calls some
command of the animation which is expected to panic on certain reason.
The test checks that those client threads will panic returning
a proper panic code. Client threads are created and tested for
the following actions:
1. A Command() call to an animation which executes
iFunctions->Panic() method. Client thread must panic with
code EWservPanicAnimDll.
2. A Command() call with dummy parameter to an animation which
executes iFunctions->Panic() method. Client thread must panic
with code EWservPanicAnimDll.
3. A CommandReply() call to an animation which executes
iFunctions->Panic() method. Client thread must panic with code
EWservPanicAnimDll.
4. A CommandReply() call with dummy parameter to an animation
which executes iFunctions->Panic() method. Client thread must
panic with code EWservPanicAnimDll.
5. A command that calls MAnimGeneralFunctions::SetInterval() when
the synchronisation mode is not TAnimSync::ESyncNone. Client
thread must panic with code EWservPanicAnimDll.
6. A command that calls MAnimGeneralFunctions::SetNextInterval()
when the synchronisation mode is not TAnimSync::ESyncNone. Client
thread must panic with code EWservPanicAnimDll.
7. A command that calls MAnimGeneralFunctions::DuplicateFontL() to
duplicate undefined font. Client thread must panic with code
EWservPanicFont.
8. A command that calls MAnimGeneralFunctions::DuplicateBitmapL()
to duplicate undefined bitmap. Client thread must panic with code
EWservPanicBitmap.
9. A command that calls User::Leave(KErrGeneral). Client thread
must panic with code EWservPanicAnimLeave.
10. A command that activates window animation's graphical context
twice. Client thread must panic with code EWservPanicAnimDll.
11. A command that tries to draw a rectangle while graphical
context is not defined yet. Client thread must panic with code
EWservPanicAnimLeave.
12. A command that tries to draw a text whihout a font defined yet.
Client thread must panic with code EWservPanicNoFont.
13. A command that causes an animation to leave during execution
of CAnim::Animate() method; and a new command call 4 seconds after
that. Client thread must panic with code EWservPanicAnimLeave.
14. A command that causes an animation to leave during execution
of CAnim::Redraw() method. The client thread initiates it's window
redraw after that. Client thread must panic with code
EWservPanicAnimLeave.
15. The client thread calls RWsSession::TestWrite() on animation
DLL server-side handle with opcode 999. Client thread must panic with code
EWservPanicOpcode.
16. A command that activates graphical context and sets the
window to invisible and then to visible. Client thread must panic
with code EWservPanicAnimDll.
@SYMTestExpectedResults See test actions.
*/
void CTAnimDll::TestPanicsL()
{
TInt index=0;
TBool finishTests=EFalse;
do
{
TClientPanic panicCode=EWservPanicAnimDll;
switch(index)
{
// panic the server with a KERN-4. When server fixed these this can be removed.
case 19:
case 20:
case 22:
case 24:
goto bypasstest;
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 10:
case 16:
case 17:
case 18:
case 73:
case 74:
panicCode=EWservPanicAnimDll;
break;
case 7:
panicCode=EWservPanicFont;
break;
case 8:
panicCode=EWservPanicBitmap;
break;
case 12:
case 69:
case 70:
case 71:
panicCode=EWservPanicNoFont;
break;
case 15:
panicCode=EWservPanicOpcode;
break;
case 9:
case 11:
case 13:
case 14:
case 72:
default: // cases 19 - 68
panicCode=EWservPanicAnimLeave;
break;
}
TEST(iTest->TestWsPanicL(&DoPanicTest,panicCode,index,(TAny*)iTest->iScreenNumber,&finishTests));
bypasstest:
if (iTest->iScreenNumber == 0)
iTest->CloseAllPanicWindows();
index++;
} while(!finishTests);
}
void CTAnimDll::TestSyncModes(MAnimGeneralFunctions::TAnimSync aSyncMode)
{
RTestAnim anim=RTestAnim(iAnimDll);
User::LeaveIfError(anim.Construct(*iTestWin->BaseWin(),EAnimTypeTest1,TPtrC8()));
CleanupClosePushL(anim);
TPckgBuf<TSyncTests> params;
TRequestStatus status(KRequestPending);
params().status=&status;
params().syncMode=aSyncMode;
anim.CommandReply(EADllSyncTests,params);
User::WaitForRequest(status);
TEST(status==KErrNone);
CleanupStack::PopAndDestroy(&anim);
}
void CTAnimDll::TestTimeChange()
{
RTestAnim anim=RTestAnim(iAnimDll);
User::LeaveIfError(anim.Construct(*iTestWin->BaseWin(),EAnimTypeTest1,TPtrC8()));
CleanupClosePushL(anim);
TPckgBuf<TTimeChangeTest> params;
TRequestStatus status(KRequestPending);
TRequestStatus status2(KRequestPending);
params().status=&status;
params().status2=&status2;
anim.CommandReply(EADllTimeChangedTest,params);
User::WaitForRequest(status);
TTime time;
time.HomeTime();
time+=TTimeIntervalHours(1);
User::SetHomeTime(time);
User::WaitForRequest(status2);
time.HomeTime();
time-=TTimeIntervalHours(1);
User::SetHomeTime(time);
TEST(status2==KErrNone);
CleanupStack::PopAndDestroy(&anim);
}
void CTAnimDll::ConstructL()
{
TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(0);
iRedrawWin=new(ELeave) CAnimWindow(EFalse, CAnimWindow::ERedraw);
iBackedUpTestWin=new(ELeave) CAnimWindow(EFalse, CAnimWindow::EBackedUp);
iBlankTestWin=new(ELeave) CAnimWindow(EFalse, CAnimWindow::EBlank);
iBaseWin=new(ELeave) CAnimWindow(ETrue, CAnimWindow::ERedraw);
//
TSize screenSize=TheClient->iGroup->Size();
TInt winWidth=(screenSize.iWidth/3)-10;
TInt winHeight=screenSize.iHeight-10;
iBaseWin->ConstructL(TPoint(screenSize.iWidth/3+5,5),TSize(winWidth,winHeight));
iBlankTestWin->ConstructL(TPoint(screenSize.iWidth/3*2+5,5),TSize(winWidth,winHeight));
((RBlankWindow *)iBlankTestWin->BaseWin())->SetColor(TRgb::Gray4(2));
iBackedUpTestWin->ConstructL(TPoint(screenSize.iWidth/3*2+5,5),TSize(winWidth,winHeight));
iRedrawWin->ConstructL(TPoint(screenSize.iWidth/3*2+5,5),TSize(winWidth,winHeight));
//
iTestWin=iRedrawWin;
//
iAnimDll=RAnimDll(TheClient->iWs);
TInt retVal = iAnimDll.Load(KAnimDLLName);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("iAnimDll.Load(KAnimDLLName) return value - Expected: %d , Actual: %d"), KErrNone, retVal);
}
CTAnimDll::~CTAnimDll()
{
iAnimDll.Close();
delete iBackedUpTestWin;
delete iBlankTestWin;
delete iRedrawWin;
delete iBaseWin;
}
/**
@SYMTestCaseID GRAPHICS-WSERV-0126
@SYMDEF DEF081259
@SYMTestCaseDesc Miscellaneous animation tests.
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Tests window animation's window funtions like WindowSize(),
IsHidden(), SetVisible().
Tests RAnimDll's constructor, Close(), Load() and copy-constructor.
@SYMTestExpectedResults Expects window funtions and RAnimDll's methods work properly.
*/
void CTAnimDll::Misc()
{
RTestAnim anim=RTestAnim(iAnimDll);
User::LeaveIfError(anim.Construct(*iTestWin->BaseWin(),EAnimTypeTest1,TPtrC8()));
CleanupClosePushL(anim);
TPckgBuf<TSize> params;
params()=iTestWin->Size();
TBool retBool = anim.CommandReply(EADllTestWindowSize,params);
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("anim.CommandReply(EADllTestWindowSize,params) return value - Expected: %d , Actual: %d"), ETrue, retBool);
TheClient->iWs.Finish();
retBool = anim.CommandReply(EADllTestSetVisible);
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("anim.CommandReply(EADllTestSetVisible) return value - Expected: %d , Actual: %d"), ETrue, retBool);
CleanupStack::PopAndDestroy(&anim);
RAnimDll closeme(TheClient->iWs);
closeme.Close();
RAnimDll animdll(TheClient->iWs);
TInt retVal = animdll.Load(KAnimDLLName);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("animdll.Load(KAnimDLLName) return value - Expected: %d , Actual: %d"), KErrNone, retVal);
RTestAnim anim2(animdll);
anim2.Close();
animdll.Close();
}
/**
@SYMTestCaseID GRAPHICS-WSERV-0127
@SYMDEF DEF081259
@SYMTestCaseDesc Test animation's command call with reply
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Puts an array containing a sequnce of numbers into a command argument.
Performs command call to server, assuming that the server-side
should return a sum of the numbers in sequence.
@SYMTestExpectedResults Checks that server returns the correct sum.
*/
void CTAnimDll::RemoteBuffer()
{
RTestAnim anim=RTestAnim(iAnimDll);
User::LeaveIfError(anim.Construct(*iTestWin->BaseWin(),EAnimTypeTest1,TPtrC8()));
CleanupClosePushL(anim);
TBuf<ERemoteBufSize> buf(ERemoteBufSize);
TInt total=0;
for (TInt8 index=0;index<ERemoteBufSize;index++)
{
total+=index;
buf[index]=index;
}
TIpcArgs ipcArgs;
ipcArgs.Set(KIpcSlot,&buf);
TInt retVal = anim.CommandReply(EADllReadRemoteDescriptor,KNullDesC8,ipcArgs);
TEST(retVal==total);
if (retVal!=total)
INFO_PRINTF3(_L("anim.CommandReply(EADllReadRemoteDescriptor,KNullDesC8,ipcArgs) return value - Expected: %d , Actual: %d"), total, retVal);
CleanupStack::PopAndDestroy(&anim);
}
//
/**
@SYMTestCaseID GRAPHICS-WSERV-0128
@SYMDEF DEF081259
@SYMTestCaseDesc RAnimDll extracopy test
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Creates another RAnimDll instance for a dll that already has a client-side interface.
@SYMTestExpectedResults Expects that operation completes without errors.
*/
void CTAnimDll::ExtraCopyTest()
{
RAnimDll extraCopy(TheClient->iWs);
TInt retVal = extraCopy.Load(KAnimDLLName);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("extraCopy.Load(KAnimDLLName) return value - Expected: %d , Actual: %d"), KErrNone, retVal);
extraCopy.Close();
}
//
void CTAnimDll::SyncMode1()
{
TestSyncModes(MAnimGeneralFunctions::ESyncSecond);
}
void CTAnimDll::CheckWindows()
{
CheckRect(iBaseWin->CtBaseWin(),iTestWin->CtBaseWin(),TRect(iBaseWin->Size()),_L("CTAnimDll::CheckWindows() failed"));
}
void CTAnimDll::InvalidatePauseAndRedraw(const TRect &aRect,TTimeIntervalMicroSeconds32 aInterval)
{
iTestWin->Invalidate(aRect);
TheClient->iWs.Flush();
User::After(aInterval);
__ASSERT_DEBUG(iTestWin->iWinType==CAnimWindow::ERedraw,AutoPanic(EAutoPanicWindowType));
RWindow *win=(RWindow *)iTestWin->BaseWin();
win->BeginRedraw();
iTestWin->DoDraw();
win->EndRedraw();
TheClient->iWs.Flush();
}
void CTAnimDll::RedrawAndCheckWindows(TBool aBlankIt)
{
if (iTestWin->iWinType==CAnimWindow::ERedraw)
{
RWindow *win=(RWindow *)iTestWin->BaseWin();
win->BeginRedraw();
iTestWin->DoDraw(aBlankIt);
win->EndRedraw();
}
RWindow *win=(RWindow *)iBaseWin->BaseWin();
win->BeginRedraw();
iBaseWin->DoDraw(aBlankIt);
win->EndRedraw();
TheClient->WaitForRedrawsToFinish();
CheckWindows();
}
/**
@SYMTestCaseID GRAPHICS-WSERV-0129
@SYMDEF DEF081259
@SYMTestCaseDesc Animation drawing test
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Performs animation drawing ontop of redrawable window, backed-up window and blank window.
Draws the same shapes using directly window graphics on an other window (base window).
The following shapes are drawn:
1. An animation with a small ellipse drawn in XOR mode on top of redrawable
black-lined gray window.
2. The same with a bigger ellipse but previously invalidating an
area which intersects the old ellipse and the new ellipse.
3. Runs an animation that continuously moves a rectangle and shrinks another on top of
redrawable black-lined gray window and then cancels an animation.
The test checks that the window will be identical with the gray base window
that contains only black lines.
4. An animation with a small ellipse drawn in XOR mode on top of backed-up
black-lined gray window. The test also calls Invalidate() method and performs
a check again to make sure that the test-window and base window are identical.
5. An animation with a small ellipse drawn in XOR mode on top of the blank
gray window. The test also sends commands to the animation that call windows
SetVisible(EFalse) and SetVisible(ETrue) and checks that the
test-window and base window are identical.
@SYMTestExpectedResults Each time performs pixelwise comparisons of animated windows
and the base window expecting the windows to be identical.
*/
void CTAnimDll::DrawingTestL()
{
// draws a little circle on the base window using window graphics and using window animation on the test window.
RTestAnim drawAnim=RTestAnim(iAnimDll);
//
TRect rect;
TPckgBuf<TRect> rectPckg;
TPckgBuf<TBool> boolPckg;
//
_LIT(KLog1,"Draw Ellipse Test1");
LOG_MESSAGE(KLog1);
rect = TRect(10,10,50,50);
CAnimWindow::SetEllipseDrawMode(CGraphicsContext::EDrawModeXOR);
iTestWin->Invalidate();
iTestWin->SetRect(rect);
iBaseWin->Invalidate();
iBaseWin->SetRect(rect);
rectPckg()=rect;
User::LeaveIfError(drawAnim.Construct(*iTestWin->BaseWin(),EAnimTypeTest3,rectPckg));
RedrawAndCheckWindows();
//
_LIT(KLog2,"Draw Ellipse Test2");
LOG_MESSAGE(KLog2);
iTestWin->Invalidate(TRect(20,20,100,40));
iBaseWin->Invalidate(TRect(20,20,100,40));
iBaseWin->DoDrawEllipse(); // Should clear old Ellipse (except invalid bits)
rect=TRect(30,30,200,100);
rectPckg()=rect;
iBaseWin->SetRect(rect);
iBaseWin->DoDrawEllipse(); // Should draw new Ellipse (except invalid bits)
drawAnim.Command(EADllSetRect,rectPckg);
RedrawAndCheckWindows();
iBaseWin->DoDrawEllipse(); // Clear old ellipse
//
_LIT(KLog3,"Window Overlap Anim Test");
LOG_MESSAGE(KLog3);
iBaseWin->SetRect(TRect());
iBaseWin->DoDraw();
TheClient->iWs.Finish();
// create another window on top and check that animation beneath is not visible
TSize screenSize=TheClient->iGroup->Size();
TInt winWidth=(screenSize.iWidth/3)-10;
TInt winHeight=screenSize.iHeight-10;
TSize size=iTestWin->Size();
rectPckg()=TRect(size);
drawAnim.Command(EADllStartAnimate,rectPckg);
CAnimWindow *topWindow = new (ELeave) CAnimWindow(ETrue, CAnimWindow::ERedraw);
CleanupStack::PushL(topWindow);
topWindow->ConstructL(TPoint(screenSize.iWidth/3*2+5,5),TSize(winWidth,winHeight));
RWindow *win=(RWindow *)iTestWin->BaseWin();
win->BeginRedraw();
topWindow->DoDraw(EFalse);
win->EndRedraw();
TheClient->iWs.Flush();
for(TInt i=0;i<size.iWidth/2;i+=5)
InvalidatePauseAndRedraw(TRect(i,size.iHeight-i-i,i+i,size.iHeight-i),TTimeIntervalMicroSeconds32(400000));
TheClient->WaitForRedrawsToFinish();
CheckRect(iBaseWin->CtBaseWin(),iTestWin->CtBaseWin(),TRect(iBaseWin->Size()));
win->BeginRedraw(rect);
drawAnim.Command(EADllCancelAnimate,rectPckg);
win->EndRedraw();
CleanupStack::PopAndDestroy(topWindow);
//
iTestWin->BaseWin()->SetVisible(EFalse);
drawAnim.Close();
//
_LIT(KLog4,"Draw Ellipse Test4&5");
LOG_MESSAGE(KLog4);
rect=TRect(20,20,50,50);
iBackedUpTestWin->SetRect(rect);
iBackedUpTestWin->DoDraw();
iBaseWin->SetRect(rect);
win->BeginRedraw();
iBaseWin->DoDraw();
win->EndRedraw();
TheClient->iWs.Finish();
rectPckg()=rect;
User::LeaveIfError(drawAnim.Construct(*iBackedUpTestWin->BaseWin(),EAnimTypeTest3,rectPckg));
TheClient->iWs.Finish();
TheClient->WaitForRedrawsToFinish();
CheckWindows();
iBackedUpTestWin->Invalidate();
TheClient->iWs.Flush();
TheClient->WaitForRedrawsToFinish();
CheckWindows();
iBackedUpTestWin->BaseWin()->SetVisible(EFalse);
//
_LIT(KLog5,"Draw Ellipse Test6&7");
LOG_MESSAGE(KLog5);
rect=TRect(20,20,50,50);
TheClient->iWs.Flush();
RWindow *winBase=(RWindow *)iBaseWin->BaseWin();
winBase->BeginRedraw();
iBaseWin->SetRect(rect);
iBaseWin->DoDraw(ETrue);
winBase->EndRedraw();
rectPckg()=rect;
User::LeaveIfError(drawAnim.Construct(*iBlankTestWin->BaseWin(),EAnimTypeTest3,rectPckg));
TheClient->iWs.Flush();
iBlankTestWin->Invalidate();
TheClient->iWs.Flush();
TheClient->WaitForRedrawsToFinish();
CheckWindows();
boolPckg()=EFalse;
drawAnim.Command(EADllSetVisible,boolPckg);
TheClient->iWs.Flush();
boolPckg()=ETrue;
drawAnim.Command(EADllSetVisible,boolPckg);
TheClient->WaitForRedrawsToFinish();
CheckWindows();
//This test does functional coverage by calling code that executes each of the
//server's class (CWsAnimGc) members in turn.
_LIT(KLog6,"Draw Primitives (Coverage) Test");
LOG_MESSAGE(KLog6);
rect = TRect(10,10,150,150);
iBaseWin->BaseWin()->SetVisible(ETrue);
iBaseWin->SetRect(TRect(0,0,0,0));
winBase->BeginRedraw();
iBaseWin->DoDraw();
iBaseWin->SetRect(rect);
iBaseWin->DoDrawCoverage();
winBase->EndRedraw();
iTestWin->BaseWin()->SetVisible(ETrue);
iTestWin->SetRect(rect);
win->BeginRedraw();
iTestWin->DoDraw();
win->EndRedraw();
rectPckg()=rect;
User::LeaveIfError(drawAnim.Construct(*iTestWin->BaseWin(),EAnimTypeCoverage,rectPckg));
//set font
CFbsFont* font;
User::LeaveIfError(TheClient->iGc->Device()->GetNearestFontToDesignHeightInTwips((CFont*&)font, TFontSpec()));
TPckgBuf<TInt> fontHandle;
fontHandle() = font->Handle();
const TInt err = drawAnim.CommandReply(EADllSetFont, fontHandle);
TheClient->iGc->Device()->ReleaseFont(font);
User::LeaveIfError(err);
//draw
User::LeaveIfError(drawAnim.CommandReply(EADllDrawNow));
TheClient->iWs.Finish();
TheClient->WaitForRedrawsToFinish();
CheckWindows();
drawAnim.Close();
}
void CTAnimDll::ShadowDrawingTestL()
{
// Create a blank window to cast a shadow over the animation
TSize scrSize(TheClient->iScreen->SizeInPixels());
CTBlankWindow *blank=new(ELeave) CTBlankWindow();
CleanupStack::PushL(blank);
blank->SetUpL(TPoint(0,10), TSize(scrSize.iWidth,scrSize.iHeight/3), TheClient->iGroup, *TheClient->iGc);
blank->BaseWin()->SetShadowHeight(2);
iBlankTestWin->BaseWin()->SetShadowHeight(0);
//
RTestAnim drawAnim=RTestAnim(iAnimDll);
TRect rect(10,scrSize.iHeight/3-20,50,scrSize.iHeight/3+40);
TPckgBuf<TRect> rectPckg;
rectPckg()=rect;
User::LeaveIfError(drawAnim.Construct(*iBlankTestWin->BaseWin(),EAnimTypeTest3,rectPckg));
drawAnim.Command(EADllSetShadowDrawMode);
CAnimWindow::SetEllipseDrawMode(CGraphicsContext::EDrawModePEN);
//
iBlankTestWin->Invalidate();
iBlankTestWin->SetRect(rect);
iBaseWin->Invalidate();
iBaseWin->SetRect(rect);
RedrawAndCheckWindows(ETrue);
//
for(TInt ypos=10;ypos>0;ypos-=4)
{
blank->SetPos(TPoint(0,ypos));
TPckgBuf<TShadowDrawTest> params;
TRequestStatus status(KRequestPending);
params().status=&status;
drawAnim.CommandReply(EADllShadowAnimTest,params);
User::WaitForRequest(status);
RedrawAndCheckWindows(ETrue);
}
//
CleanupStack::PopAndDestroy(blank); // Destroy the shadow window
}
/**
@SYMTestCaseID GRAPHICS-WSERV-0130
@SYMDEF DEF081259
@SYMTestCaseDesc Complicated drawing test
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Performs complicated drawing both through the animation on
a blank window and through direct fbs drawing on the second
window.
@SYMTestExpectedResults Expects the both windows to be are identical
*/
void CTAnimDll::GeneralDrawingTestL()
{
// This test has been removed as it is no longer relevant
// Anims are not allowed to draw immediately to the screen
}
/**
@SYMTestCaseID GRAPHICS-WSERV-0131
@SYMDEF DEF081259
@SYMTestCaseDesc Animated window destruction test
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Creates a window and a child window inside it, runs an animation
in the child window in ESyncFlash mode, destroys windows.
@SYMTestExpectedResults Expects the operations not to fail.
*/
void CTAnimDll::DestroyWindowTestL()
{
RWindow window(TheClient->iWs);
User::LeaveIfError(window.Construct(*TheClient->iGroup->GroupWin(),123));
CleanupClosePushL(window);
window.SetSize(TSize(100,100));
window.Activate();
RWindow window2(TheClient->iWs);
CleanupClosePushL(window2);
User::LeaveIfError(window2.Construct(window,124));
window2.Activate();
window2.BeginRedraw(); // Validate it
window2.EndRedraw();
//
RTestAnim drawAnim;
drawAnim=RTestAnim(iAnimDll);
TRect rect(10,10,50,50);
TPckgBuf<TRect> rectPckg;
rectPckg()=rect;
User::LeaveIfError(drawAnim.Construct(window2,EAnimTypeTest3,rectPckg));
drawAnim.Command(EADllStartAnimate,rectPckg);
CleanupStack::Pop(&window2);
CleanupStack::PopAndDestroy(&window);
TheClient->iWs.Flush();
User::After(TTimeIntervalMicroSeconds32(2000000));
window2.Close();
drawAnim.Close();
}
void CTAnimDll::SetUpMember(TSpriteMember &aMember,TInt aType)
{
switch (aType)
{
case 1:
iTest->SetUpMember(aMember);
aMember.iOffset=TPoint();
aMember.iInterval=TTimeIntervalMicroSeconds32(1);
break;
case 2:
aMember.iInvertMask=EFalse;
aMember.iDrawMode=CGraphicsContext::EDrawModeXOR;
aMember.iOffset=TPoint(1,2);
aMember.iInterval=TTimeIntervalMicroSeconds32(2);
break;
case 3:
aMember.iInvertMask=ETrue;
aMember.iDrawMode=CGraphicsContext::EDrawModeOR;
aMember.iOffset=TPoint(3,4);
aMember.iInterval=TTimeIntervalMicroSeconds32(3);
break;
default:
iTest->SetUpMember(aMember);
}
}
/**
@SYMTestCaseID GRAPHICS-WSERV-0132
@SYMDEF DEF081259
@SYMTestCaseDesc Sprite animation test
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Creates a sprite with three sprite members and a sprite animation
passing the sprite to it. The test updates sprite members'
properties in various ways verifying that the properties are changing
on the server-side as well.
@SYMTestExpectedResults Expects that operations above do not fail and that client-side
changes to the sprite affect server-side properly.
*/
#define HALF_SEC 500000
void CTAnimDll::SpriteAnimL()
{
// create a sprite, add 3 members to it
RWsSprite sprite(TheClient->iWs);
iRedrawWin->BaseWin()->SetVisible(ETrue);
sprite.Construct(*iRedrawWin->CtBaseWin()->BaseWin(),TPoint(),0);
CleanupClosePushL(sprite);
CFbsBitmap* bitmap1=new(ELeave) CFbsBitmap();
CleanupStack::PushL(bitmap1);
CFbsBitmap* bitmap2=new(ELeave) CFbsBitmap();
CleanupStack::PushL(bitmap2);
CFbsBitmap* bitmap3=new(ELeave) CFbsBitmap();
CleanupStack::PushL(bitmap3);
User::LeaveIfError(bitmap1->Create(TSize(10,12),EGray4));
User::LeaveIfError(bitmap2->Create(TSize(15,17),EGray4));
User::LeaveIfError(bitmap3->Create(TSize(20,22),EGray4));
TSpriteMember member1;
TSpriteMember member2;
TSpriteMember member3;
SetUpMember(member1,1);
member1.iBitmap=bitmap1;
member1.iMaskBitmap=bitmap1;
SetUpMember(member2,2);
member2.iBitmap=bitmap2;
member2.iMaskBitmap=bitmap2;
SetUpMember(member3,3);
member3.iBitmap=bitmap3;
member3.iMaskBitmap=bitmap3;
sprite.AppendMember(member1);
sprite.AppendMember(member2);
sprite.AppendMember(member3);
// create a sprite animation for the sprite
RTestAnim spriteAnim(iAnimDll);
TPtrC8 des(NULL,0);
TPoint pos(1,2);
User::LeaveIfError(spriteAnim.Construct(sprite,EAnimTypeSprite,des));
CleanupClosePushL(spriteAnim);
// call EADllCheckMember-command to verify that sprite animation's members
// have the same properties as the sprite instance
TPckgBuf<TSpriteMemberInfo> spriteInfo;
spriteInfo()=TSpriteMemberInfo(TPoint(),0,member1);
TBool retBool = spriteAnim.CommandReply(EADllCheckMember,spriteInfo);
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("spriteAnim.CommandReply(EADllCheckMember,spriteInfo) return value - Expected: %d , Actual: %d"), ETrue, retBool);
sprite.SetPosition(pos);
spriteInfo()=TSpriteMemberInfo(pos,1,member2);
retBool = spriteAnim.CommandReply(EADllCheckMember,spriteInfo);
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("spriteAnim.CommandReply(EADllCheckMember,spriteInfo) return value - Expected: %d , Actual: %d"), ETrue, retBool);
pos.SetXY(3,4);
sprite.SetPosition(pos);
spriteInfo()=TSpriteMemberInfo(pos,2,member3);
retBool = spriteAnim.CommandReply(EADllCheckMember,spriteInfo);
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("spriteAnim.CommandReply(EADllCheckMember,spriteInfo) return value - Expected: %d , Actual: %d"), ETrue, retBool);
// call commands to change sprite members' bitmaps and update members
spriteAnim.Command(EADllDraw1);
spriteAnim.Command(EADllDraw2);
spriteAnim.Command(EADllDraw3);
TheClient->iWs.Flush();
User::After(HALF_SEC);
// call commands to change sprite's position
TPckgBuf<TPoint> position;
position().SetXY(60,50);
spriteAnim.Command(EADllSetPos,position);
TheClient->iWs.Flush();
User::After(HALF_SEC);
// change 1st member's bitmap size and interval, update it and call command to check
// that the new properties are applied
User::LeaveIfError(bitmap1->Resize(TSize(30,32)));
member1.iMaskBitmap=NULL;
member1.iInterval=TTimeIntervalMicroSeconds32(25);
User::LeaveIfError(sprite.UpdateMember(0,member1));
spriteInfo()=TSpriteMemberInfo(TPoint(),0,member1);
retBool = spriteAnim.CommandReply(EADllCheckMember,spriteInfo);
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("spriteAnim.CommandReply(EADllCheckMember,spriteInfo) return value - Expected: %d , Actual: %d"), ETrue, retBool);
User::After(HALF_SEC);
// change 1st member's bitmap size and calls command that invokes
// MAnimSpriteFunctions::SizeChangedL(). Check that new property is applied
spriteAnim.CommandReply(EADllDeactivate);
User::LeaveIfError(bitmap1->Resize(TSize(35,37)));
spriteAnim.Command(EADllSizeChanged);
spriteAnim.CommandReply(EADllActivate);
spriteInfo()=TSpriteMemberInfo(TPoint(),0,member1);
retBool = spriteAnim.CommandReply(EADllCheckMember,spriteInfo);
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("spriteAnim.CommandReply(EADllCheckMember,spriteInfo) return value - Expected: %d , Actual: %d"), ETrue, retBool);
User::After(HALF_SEC);
// call command that changes 1st member's bitmap image
spriteAnim.Command(EADllIncDraw);
TheClient->iWs.Flush();
User::After(HALF_SEC);
CleanupStack::PopAndDestroy(5,&sprite);
}
/**
@SYMTestCaseID GRAPHICS-WSERV-0133
@SYMDEF DEF081259
@SYMTestCaseDesc Free timer animation test
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions The test creates a free timer window animation that animates
a shrinking filled rect which changes colour in a predefined way.
@SYMTestExpectedResults The test verifies that the colour changes gets through to the the display.
*/
#define NOT_TIMED_OUT timeWaitingForFrame < frametime<<4
void CTAnimDll::FreeTimerL()
{
RTestAnim freeTimerAnim(iAnimDll);
User::LeaveIfError(freeTimerAnim.Construct(*iRedrawWin->BaseWin(),EAnimTypeFreeTimer,KNullDesC8));
CleanupClosePushL(freeTimerAnim);
const TInt frametime = 100000; // 100 ms
const TInt samplingtime = frametime>>1; // 50 ms
TPckgC<TInt> frametimeBuf(frametime);
freeTimerAnim.Command(ESetFrameTime, frametimeBuf);
freeTimerAnim.Command(EStartAnimation);
TheClient->iWs.Flush();
TheClient->iWs.Finish();
TInt x = iRedrawWin->BaseWin()->AbsPosition().iX + (iRedrawWin->BaseWin()->Size().iWidth >> 1);
TInt y = iRedrawWin->BaseWin()->AbsPosition().iY + (iRedrawWin->BaseWin()->Size().iHeight >> 1);
TPoint middle(x,y);
TRgb color = KRgbMagenta;
TBool foundRedFrame = EFalse;
TBool foundGreenFrame = EFalse;
TBool foundBlueFrame = EFalse;
TBool foundBlackFrame = EFalse;
//The free-timer animates the colour in this predefined way.
//Test that the screen gets updated.
TInt timeWaitingForFrame = 0;
while(NOT_TIMED_OUT && !(foundRedFrame && foundGreenFrame && foundBlueFrame && foundBlackFrame)) //wait max 16*frametime=1280ms
{
//wait for the colour frame
color = PixelColour(middle);
if(color == KRgbRed)
{
foundRedFrame = ETrue;
}
else if(color == KRgbGreen)
{
foundGreenFrame = ETrue;
}
else if(color == KRgbBlue)
{
foundBlueFrame = ETrue;
}
else if(color == KRgbBlack)
{
foundBlackFrame = ETrue;
}
timeWaitingForFrame += samplingtime;
User::After(samplingtime);
}
TEST(foundRedFrame);
TEST(foundGreenFrame);
TEST(foundBlueFrame);
TEST(foundBlackFrame);
freeTimerAnim.Command(EStopAnimation);
CleanupStack::PopAndDestroy(&freeTimerAnim);
}
TRgb CTAnimDll::PixelColour(const TPoint& aPoint) const
{
TRgb pixel;
TheClient->iScreen->GetPixel(pixel, aPoint);
return pixel;
}
/**
@SYMTestCaseID GRAPHICS-WSERV-0134
@SYMDEF DEF081259
@SYMTestCaseDesc Animation's ESyncSecond sync-mode test
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Creates an animation in ESyncSecond sync-mode.
Checks that animation's Animate() method was called either 9, 10 or 11
times during a 10-seconds-wait.
The test also checks that if RWsSession::PrepareForSwitchOff()
is called then the Animate() method will not be called until
TRawEvent::EActive event is simulated.
@SYMTestExpectedResults See actions.
*/
static const TInt K1Second = 1000000;
static const TInt K3Seconds = 3000000;
static const TInt K9Seconds = 9500000;
void CTAnimDll::DisableTimerL()
{
//Defer start of timerAnim until the systen time are close to a full second
TTime now;
now.HomeTime();
TInt deferTime = K1Second - now.DateTime().MicroSecond();
User::After(deferTime);
//Kick off timerAnim
RTestAnim timerAnim(iAnimDll);
User::LeaveIfError(timerAnim.Construct(*iRedrawWin->BaseWin(),EAnimTypeTimer,KNullDesC8));
User::After(K9Seconds);
TInt count=timerAnim.CommandReply(EADllCurrentCount);
#if defined(LOGGING)
TLogMessageText buf;
_LIT(KLog,"Anim DisableTimer Count=%d");
buf.Format(KLog,count);
TheClient->LogMessage(buf);
#endif
TEST(count>=9 && count<=11);
if (count != 10)
INFO_PRINTF2(_L("count>=9 && count<=11 - Expected: 9,10 or 11 , Actual: %d"), count);
#if defined(__WINS__)
TheClient->iWs.SimulateXyInputType(EXYInputNone); //Turn off pen in case it turns on the timer
#endif
// reset timer's counter and call RWsSession::PrepareForSwitchOff(),
// check that 3 seconds after the counter = 0
timerAnim.Command(EADllResetCount);
timerAnim.Command(EADllNoTimer);
TheClient->iWs.PrepareForSwitchOff();
TheClient->iWs.Flush();
User::After(K3Seconds);
count=timerAnim.CommandReply(EADllCurrentCount);
#if defined(LOGGING)
buf.Format(KLog,count);
TheClient->LogMessage(buf);
#endif
TEST(count==0);
if (count!=0)
INFO_PRINTF3(_L("count==0 - Expected: %d , Actual: %d"), 0, count);
// simulates TRawEvent::EActive event,
// check that the timer didn't ticked until the event were simulated
timerAnim.Command(EADllTimerStarted);
TRawEvent event;
event.Set(TRawEvent::EActive);
TheClient->iWs.SimulateRawEvent(event);
#if defined(__WINS__)
TheClient->iWs.SimulateXyInputType(EXYInputPointer); //Turn pen on again
#endif
TInt retVal = timerAnim.CommandReply(EADllFailed);
TEST(retVal==0);
if (retVal!=0)
INFO_PRINTF3(_L("timerAnim.CommandReply(EADllFailed) return value - Expected: %d , Actual: %d"), 0, retVal);
timerAnim.Close();
}
/**
@SYMTestCaseID GRAPHICS-WSERV-0135
@SYMDEF DEF081259
@SYMTestCaseDesc Multiple animations test
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Creates multiple animations for a window.
@SYMTestExpectedResults The test doesn't perform any specific validations.
*/
void CTAnimDll::MultipleAnimsL()
{
RTestAnim anim1(iAnimDll);
RTestAnim anim2(iAnimDll);
RTestAnim anim3(iAnimDll);
RTestAnim anim4(iAnimDll);
RTestAnim anim5(iAnimDll);
RTestAnim anim6(iAnimDll);
TPtrC8 des(NULL,0);
User::LeaveIfError(anim1.Construct(*iRedrawWin->BaseWin(),EAnimTypeTest3,des));
CleanupClosePushL(anim1);
User::LeaveIfError(anim2.Construct(*iRedrawWin->BaseWin(),EAnimTypeTest3,des));
CleanupClosePushL(anim2);
User::LeaveIfError(anim3.Construct(*iRedrawWin->BaseWin(),EAnimTypeTest3,des));
CleanupClosePushL(anim3);
User::LeaveIfError(anim4.Construct(*iRedrawWin->BaseWin(),EAnimTypeTest3,des));
CleanupClosePushL(anim4);
User::LeaveIfError(anim5.Construct(*iRedrawWin->BaseWin(),EAnimTypeTest3,des));
CleanupClosePushL(anim5);
User::LeaveIfError(anim6.Construct(*iRedrawWin->BaseWin(),EAnimTypeTest3,des));
anim6.Close();
User::LeaveIfError(anim6.Construct(*iRedrawWin->BaseWin(),EAnimTypeTest3,des));
anim6.Close();
User::LeaveIfError(anim6.Construct(*iRedrawWin->BaseWin(),EAnimTypeTest3,des));
CleanupStack::PopAndDestroy(&anim5);
anim6.Close();
User::LeaveIfError(anim5.Construct(*iRedrawWin->BaseWin(),EAnimTypeTest3,des));
CleanupClosePushL(anim5);
User::LeaveIfError(anim6.Construct(*iRedrawWin->BaseWin(),EAnimTypeTest3,des));
CleanupStack::Pop(&anim5);
CleanupStack::PopAndDestroy(&anim4);
anim5.Close();
anim6.Close();
User::LeaveIfError(anim4.Construct(*iRedrawWin->BaseWin(),EAnimTypeTest3,des));
CleanupStack::PopAndDestroy(&anim3);
anim4.Close();
User::LeaveIfError(anim3.Construct(*iRedrawWin->BaseWin(),EAnimTypeTest3,des));
CleanupStack::PopAndDestroy(&anim2);
anim3.Close();
User::LeaveIfError(anim2.Construct(*iRedrawWin->BaseWin(),EAnimTypeTest3,des));
CleanupStack::PopAndDestroy(&anim1);
anim2.Close();
}
/**
@SYMTestCaseID GRAPHICS-WSERV-0136
@SYMDEF DEF081259
@SYMTestCaseDesc Click plugin DLL test
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Created two handles for a click plugin dll (RSoundPlugIn instances).
Plays with Load(), Unload() methods to verify that they affect
IsLoaded() call result.
Checks that CommandReply() for different opcodes
returns RSoundPlugIn::ESoundWrongPlugIn value.
Plays with SetPenClick(), SetKeyClick() to verify that they affect
PenClickEnabled() and KeyClickEnabled() call result.
@SYMTestExpectedResults The test checks that RSoundPlugIn's methods work properly
and that both handles behave identically.
*/
void CTAnimDll::ClickPlugInL()
{
_LIT(KDllName,"CLICK");
RWsSession ws;
User::LeaveIfError(ws.Connect());
CleanupClosePushL(ws);
TBool retBool;
TInt retVal;
// assign to the correct screen
CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws);
CleanupStack::PushL(screen);
User::LeaveIfError(screen->Construct(iTest->iScreenNumber));
RSoundPlugIn click1(ws);
RSoundPlugIn click2(TheClient->iWs);
User::LeaveIfError(click1.Construct());
CleanupClosePushL(click1);
User::LeaveIfError(click2.Construct());
CleanupClosePushL(click2);
TBool changeable1;
TBool changeable2;
TBool loaded=click1.IsLoaded(changeable1);
//test that either both are loaded or both are not loaded
TEST(!loaded==!click2.IsLoaded(changeable2));
if (!loaded!=!click2.IsLoaded(changeable2))
INFO_PRINTF3(_L("!loaded==!click2.IsLoaded(changeable2) - Expected: %d , Actual: %d"), !loaded, !click2.IsLoaded(changeable2));
//test that either both are changeable or both are not changeable
TEST(!changeable1==!changeable2);
if (!changeable1!=!changeable2)
INFO_PRINTF3(_L("!changeable1==!changeable2) - Expected: %d , Actual: %d"), !changeable1, !changeable2);
if (loaded && changeable1)
{
// unload the first one
User::LeaveIfError(click1.Unload());
// check that the second is not loaded and still changeable
retBool = !click2.IsLoaded(changeable2);
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("!click2.IsLoaded(changeable2) return value - Expected: %d , Actual: %d"), ETrue, retBool);
TEST(changeable2);
if (!changeable2)
INFO_PRINTF3(_L("changeable2 - Expected: %d , Actual: %d"), ETrue, changeable2);
// load the first one and check that the second became loaded and is changeable
User::LeaveIfError(click1.Load(KDllName));
retBool = click2.IsLoaded(changeable2);
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("click2.IsLoaded(changeable2) return value - Expected: %d , Actual: %d"), ETrue, retBool);
TEST(changeable2);
if (!changeable2)
INFO_PRINTF3(_L("changeable2 - Expected: %d , Actual: %d"), ETrue, changeable2);
// unload the second one
User::LeaveIfError(click2.Unload());
// check that the first is not loaded and still changeable
retBool = !click1.IsLoaded(changeable1);
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("!click1.IsLoaded(changeable1) return value - Expected: %d , Actual: %d"), ETrue, retBool);
TEST(changeable1);
if (!changeable1)
INFO_PRINTF3(_L("changeable1 - Expected: %d , Actual: %d"), ETrue, changeable1);
// load the second one and check that the first one became loaded and is changeable
User::LeaveIfError(click2.Load(KDllName));
loaded=click1.IsLoaded(changeable1);
TEST(loaded);
if (!loaded)
INFO_PRINTF3(_L("loaded - Expected: %d , Actual: %d"), ETrue, loaded);
TEST(changeable1);
if (!changeable1)
INFO_PRINTF3(_L("changeable1 - Expected: %d , Actual: %d"), ETrue, changeable1);
}
if (loaded)
{
TPtrC8 des(NULL,0);
retVal = click1.CommandReply(0,des);
TEST(RSoundPlugIn::ESoundWrongPlugIn==retVal);
if (RSoundPlugIn::ESoundWrongPlugIn!=retVal)
INFO_PRINTF3(_L("click1.CommandReply(0,des) return value - Expected: %d , Actual: %d"), RSoundPlugIn::ESoundWrongPlugIn, retVal);
retVal = click1.CommandReply(1,des);
TEST(RSoundPlugIn::ESoundWrongPlugIn==retVal);
if (RSoundPlugIn::ESoundWrongPlugIn!=retVal)
INFO_PRINTF3(_L("click1.CommandReply(1,des) return value - Expected: %d , Actual: %d"), RSoundPlugIn::ESoundWrongPlugIn, retVal);
retVal = click1.CommandReply(2,des);
TEST(RSoundPlugIn::ESoundWrongPlugIn==retVal);
if (RSoundPlugIn::ESoundWrongPlugIn!=retVal)
INFO_PRINTF3(_L("click1.CommandReply(2,des) return value - Expected: %d , Actual: %d"), RSoundPlugIn::ESoundWrongPlugIn, retVal);
retVal = click1.CommandReply(-1,des);
TEST(RSoundPlugIn::ESoundWrongPlugIn==retVal);
if (RSoundPlugIn::ESoundWrongPlugIn!=retVal)
INFO_PRINTF3(_L("click1.CommandReply(-1,des) return value - Expected: %d , Actual: %d"), RSoundPlugIn::ESoundWrongPlugIn, retVal);
retBool = click1.KeyClickEnabled();
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("click1.KeyClickEnabled() return value - Expected: %d , Actual: %d"), ETrue, retBool);
retBool = click1.PenClickEnabled();
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("click1.PenClickEnabled() return value - Expected: %d , Actual: %d"), ETrue, retBool);
click1.SetPenClick(EFalse);
retBool = click1.KeyClickEnabled();
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("click1.KeyClickEnabled() return value - Expected: %d , Actual: %d"), ETrue, retBool);
retBool = !click1.PenClickEnabled();
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("!click1.PenClickEnabled() return value - Expected: %d , Actual: %d"), ETrue, retBool);
click1.SetKeyClick(EFalse);
retBool = !click1.KeyClickEnabled();
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("!click1.KeyClickEnabled() return value - Expected: %d , Actual: %d"), ETrue, retBool);
retBool = !click1.PenClickEnabled();
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("!click1.PenClickEnabled() return value - Expected: %d , Actual: %d"), ETrue, retBool);
click1.SetPenClick(ETrue);
retBool = !click1.KeyClickEnabled();
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("!click1.KeyClickEnabled() return value - Expected: %d , Actual: %d"), ETrue, retBool);
retBool = click1.PenClickEnabled();
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("click1.PenClickEnabled() return value - Expected: %d , Actual: %d"), ETrue, retBool);
click1.SetKeyClick(ETrue);
retBool = click1.KeyClickEnabled();
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("click1.KeyClickEnabled() return value - Expected: %d , Actual: %d"), ETrue, retBool);
retBool = click1.PenClickEnabled();
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("click1.PenClickEnabled() return value - Expected: %d , Actual: %d"), ETrue, retBool);
/*RLibrary lib;
TInt err=lib.Load(KDllName);
if (err==KErrNone)
{
TPtrC8 des(NULL,0);
TEST(lib.Type()[2].iUid==click1.CommandReply(0,des));
lib.Close();
}*/
}
CleanupStack::PopAndDestroy(4,&ws);
}
void CTAnimDll::TestWindowInfo(RTestAnim& aAnim,TInt aScreen,TInt aPos,TInt aId)
{
TPckgBuf<TWindowGroupInfoParms> params;
params().iScreen=aScreen;
params().iOrdinalPosition=aPos;
TPckgBuf<MAnimGeneralFunctionsWindowExtension::TWindowGroupInfo> winGpInfo;
TIpcArgs ipcArgs;
ipcArgs.Set(KIpcSlot,&winGpInfo);
TBool retBool = aAnim.CommandReply(EADllWindowGroupInfo,params,ipcArgs);
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("aAnim.CommandReply(EADllWindowGroupInfo,params,ipcArgs) return value - Expected: %d , Actual: %d"), ETrue, retBool);
MAnimGeneralFunctionsWindowExtension::TWindowGroupInfo& info=winGpInfo();
TEST(info.iId==aId);
if (info.iId!=aId)
INFO_PRINTF3(_L("winGpInfo() return value - Expected: %d , Actual: %d"), aId, info.iId);
TInt retVal = TheClient->iWs.GetWindowGroupOrdinalPriority(aId);
TEST(info.iOrdinalPriority==retVal);
if (info.iOrdinalPriority!=retVal)
INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupOrdinalPriority(aId) return value - Expected: %d , Actual: %d"), info.iOrdinalPriority, retVal);
TBuf<64> windowGroupNameS;
TBuf<64> windowGroupNameA;
TheClient->iWs.GetWindowGroupNameFromIdentifier(aId,windowGroupNameS);
retVal = windowGroupNameS.Length();
TEST(info.iNameLength==retVal);
if (info.iNameLength!=retVal)
INFO_PRINTF3(_L("windowGroupNameS.Length() return value - Expected: %d , Actual: %d"), info.iNameLength, retVal);
if (info.iNameLength<64)
{
ipcArgs.Set(KIpcSlot,&windowGroupNameA);
retBool = aAnim.CommandReply(EADllWindowGroupName,params,ipcArgs);
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("aAnim.CommandReply(EADllWindowGroupName,params,ipcArgs) return value - Expected: %d , Actual: %d"), ETrue, retBool);
if (info.iNameLength>0)
{
TEST(windowGroupNameA==windowGroupNameS);
}
else
{
TEST(windowGroupNameA.Length()==0);
if (windowGroupNameA.Length()!=0)
INFO_PRINTF3(_L("iwindowGroupNameA.Length()==0 - Expected: %d, Actual: %d"), 0, windowGroupNameA.Length());
}
}
TEST(info.iParentId>=-1);
if (info.iParentId<-1)
INFO_PRINTF3(_L("info.iParentId>=-1 - Expected: %d or greater, Actual: %d"), -1, info.iParentId);
}
void CTAnimDll::TestEventHandlerRemovalL()
{
RTestAnim anim(iAnimDll);
User::LeaveIfError(anim.Construct(*iRedrawWin->BaseWin(),EAnimTypeEventHandler,KNullDesC8));
anim.Close();
}
/**
@SYMTestCaseID GRAPHICS-WSERV-0137
@SYMDEF DEF081259
@SYMTestCaseDesc Animation's extended window functions test
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions The test creates a window animation that has a couple of
commands that work with extended window functions encapsulated
into MAnimGeneralFunctionsWindowExtension class instance.
The test calls those commands to compare MAnimGeneralFunctionsWindowExtension's
methods' results with the results retuned by WSERV client classes.
MAnimGeneralFunctionsWindowExtension methods tested here:
Screens(), FocusScreens(), WindowGroups(), WindowGroupInfo(),
WindowGroupName()
@SYMTestExpectedResults MAnimGeneralFunctionsWindowExtension methods must give the same results as
the corresponding WSERV client methods would.
*/
void CTAnimDll::WinFunctionsL()
{
RTestAnim anim(iAnimDll);
User::LeaveIfError(anim.Construct(*iRedrawWin->BaseWin(),EAnimTypeWindowFunctions,KNullDesC8));
CleanupClosePushL(anim);
TInt screens=anim.CommandReply(EADllScreen);
TEST(screens>0);
if (screens<=0)
INFO_PRINTF3(_L("anim.CommandReply(EADllScreen) return value - Expected: %d or greater, Actual: %d"), 1, screens);
TInt focusScreen=anim.CommandReply(EADllFocusScreen);
TInt retVal = TheClient->iWs.GetFocusScreen();
TEST(focusScreen==retVal && focusScreen<=screens);
if (focusScreen!=retVal || focusScreen>screens)
INFO_PRINTF4(_L("anim.CommandReply(EADllFocusScreen) return value - Expected: %d and less than or equal to %d, Actual: %d"), retVal, screens, focusScreen);
TInt ii;
TPckgBuf<TInt> screen;
CArrayPtrFlat<CMinWin>* wins=new(ELeave) CArrayPtrFlat<CMinWin>(screens);
CleanupStack::PushL(wins);
// create one window on each screen
for(ii=0;ii<screens;++ii)
{
CMinWin* win=new(ELeave) CMinWin(ii);
CleanupStack::PushL(win);
win->ConstructL();
wins->AppendL(win);
}
if (screens>1)
{
for (ii=screens-1;ii>=0;--ii)
{
TheClient->iWs.SetFocusScreen(ii);
retVal = anim.CommandReply(EADllFocusScreen);
TEST(retVal==ii);
if (retVal!=ii)
INFO_PRINTF3(_L("anim.CommandReply(EADllFocusScreen) return value - Expected: %d, Actual: %d"), ii, retVal);
}
for (ii=screens-1;ii>=0;--ii)
{
screen()=ii;
anim.CommandReply(EADllSetFocusScreen,screen);
retVal = anim.CommandReply(EADllFocusScreen);
TEST(retVal==ii);
if (retVal!=ii)
INFO_PRINTF3(_L("anim.CommandReply(EADllFocusScreen) return value - Expected: %d, Actual: %d"), ii, retVal);
}
}
TheClient->iWs.SetFocusScreen(focusScreen);
retVal = anim.CommandReply(EADllFocusScreen);
TEST(retVal==focusScreen);
if (retVal!=focusScreen)
INFO_PRINTF3(_L("anim.CommandReply(EADllFocusScreen) return value - Expected: %d, Actual: %d"), focusScreen, retVal);
TInt winGroupsAll=0;
for(ii=0;ii<screens;++ii)
{
screen()=ii;
winGroupsAll+=anim.CommandReply(EADllWindowGroups,screen);
}
TInt winGroupsS=TheClient->iWs.NumWindowGroups();
TEST(winGroupsAll==winGroupsS);
if (winGroupsAll!=winGroupsS)
INFO_PRINTF3(_L("TheClient->iWs.NumWindowGroups() return value - Expected: %d, Actual: %d"), winGroupsS, winGroupsAll);
// the remaining test will use winGroupsA and performed on current focus screen only
screen()=iTest->iScreenNumber;
TInt winGroupsA=anim.CommandReply(EADllWindowGroups,screen);
CArrayFixFlat<TInt>* windowList=new(ELeave) CArrayFixFlat<TInt>(3);
CleanupStack::PushL(windowList);
// wserv implementation returns window groups from current focus screen, followed by the rest
TheClient->iWs.WindowGroupList(windowList);
// only interested in window group from current focus screen
for (ii=0;ii<winGroupsA;++ii)
TestWindowInfo(anim,iTest->iScreenNumber,ii,(*windowList)[ii]);
TPckgBuf<MAnimGeneralFunctionsWindowExtension::TWindowGroupInfo> winGpInfo;
TIpcArgs ipcArgs;
TPckgBuf<TWindowGroupInfoParms> params;
params().iScreen=iTest->iScreenNumber;
params().iOrdinalPosition=winGroupsA;
ipcArgs.Set(KIpcSlot,&winGpInfo);
TBuf<64> windowGroupName;
TBool retBool = !anim.CommandReply(EADllWindowGroupInfo,params,ipcArgs);
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("!anim.CommandReply(EADllWindowGroupInfo,params,ipcArgs) return value - Expected: %d, Actual: %d"), ETrue, retBool);
ipcArgs.Set(KIpcSlot,&windowGroupName);
retBool = !anim.CommandReply(EADllWindowGroupName,params,ipcArgs);
TEST(retBool);
if (!retBool)
INFO_PRINTF3(_L("!anim.CommandReply(EADllWindowGroupName,params,ipcArgs) return value - Expected: %d, Actual: %d"), ETrue, retBool);
/*params().iOrdinalPosition=-1; //Behaviour for negative positions not defined - but as writtin this code will pass
ipcArgs.Set(KIpcSlot,&winGpInfo);
TEST(anim.CommandReply(EADllWindowGroupInfo,params,ipcArgs));
ipcArgs.Set(KIpcSlot,&windowGroupNameA);
TEST(anim.CommandReply(EADllWindowGroupName,params,ipcArgs));*/
RWindowGroup group(TheClient->iWs);
User::LeaveIfError(group.Construct(ENullWsHandle));
CleanupClosePushL(group);
_LIT(KGroupName,"Testxyz1234");
group.SetName(KGroupName);
group.SetOrdinalPosition(0,TheClient->iWs.GetWindowGroupOrdinalPriority((*windowList)[0])+1);
TInt groupId=group.Identifier();
TestWindowInfo(anim,iTest->iScreenNumber,0,groupId);
group.SetOrdinalPosition(0,TheClient->iWs.GetWindowGroupOrdinalPriority((*windowList)[winGroupsA-1])-1);
TestWindowInfo(anim,iTest->iScreenNumber,winGroupsA,groupId);
CleanupStack::PopAndDestroy(screens+4,&anim);
// Restore us back to the front
TheClient->iGroup->GroupWin()->SetOrdinalPosition(0);
}
/**
@SYMTestCaseID GRAPHICS-WSERV-0138
@SYMDEF DEF081259
@SYMTestCaseDesc Animation's extended window functions test 2
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions The test creates a window animation that has a command
for setting window's ordinal position and priority.
The test creates 4 window groups with the same priority and
checks that they have correct ordinal positions after the creation.
After that the test plays with updating ordinal positions and
priorities of the window groups using the animation's command.
@SYMTestExpectedResults The test checks that the command was executed with no errors
and affected ordinal positions of the window groups properly.
*/
void CTAnimDll::WinFunctions2L()
{
RTestAnim anim(iAnimDll);
User::LeaveIfError(anim.Construct(*iRedrawWin->BaseWin(),EAnimTypeWindowFunctions,KNullDesC8));
CleanupClosePushL(anim);
CArrayFixFlat<TInt>* windowList=new(ELeave) CArrayFixFlat<TInt>(3);
TheClient->iWs.WindowGroupList(windowList);
TInt priority=TheClient->iWs.GetWindowGroupOrdinalPriority((*windowList)[0])+2;
delete windowList;
RWindowGroup group1(TheClient->iWs);
User::LeaveIfError(group1.Construct(ENullWsHandle));
CleanupClosePushL(group1);
group1.SetOrdinalPosition(0,priority);
RWindowGroup group2(TheClient->iWs);
User::LeaveIfError(group2.Construct(ENullWsHandle));
CleanupClosePushL(group2);
group2.SetOrdinalPosition(0,priority);
RWindowGroup group3(TheClient->iWs);
User::LeaveIfError(group3.Construct(ENullWsHandle));
CleanupClosePushL(group3);
group3.SetOrdinalPosition(0,priority);
RWindowGroup group4(TheClient->iWs);
User::LeaveIfError(group4.Construct(ENullWsHandle));
CleanupClosePushL(group4);
group4.SetOrdinalPosition(0,priority);
TInt retVal = group1.OrdinalPosition();
TEST(retVal==3);
if (retVal!=3)
INFO_PRINTF3(_L("group1.OrdinalPosition() return value - Expected: %d, Actual: %d"), 3, retVal);
retVal = group2.OrdinalPosition();
TEST(retVal==2);
if (retVal!=2)
INFO_PRINTF3(_L("group2.OrdinalPosition() return value - Expected: %d, Actual: %d"), 2, retVal);
retVal = group3.OrdinalPosition();
TEST(retVal==1);
if (retVal!=1)
INFO_PRINTF3(_L("group3.OrdinalPosition() return value - Expected: %d, Actual: %d"), 1, retVal);
retVal = group4.OrdinalPosition();
TEST(retVal==0);
if (retVal!=0)
INFO_PRINTF3(_L("group4.OrdinalPosition() return value - Expected: %d, Actual: %d"), 0, retVal);
TPckgBuf<TSetOrdinalParms> params;
params().iIdentifier=group4.Identifier();
params().iOrdinalPriority=priority;
params().iOrdinalPosition=1;
retVal = anim.CommandReply(EADllSetOrdinalPosition,params);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("anim.CommandReply(EADllSetOrdinalPosition,params) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
retVal = group3.OrdinalPosition();
TEST(retVal==0);
if (retVal!=0)
INFO_PRINTF3(_L("group3.OrdinalPosition() return value - Expected: %d, Actual: %d"), 0, retVal);
retVal = group4.OrdinalPosition();
TEST(retVal==1);
if (retVal!=1)
INFO_PRINTF3(_L("group4.OrdinalPosition() return value - Expected: %d, Actual: %d"), 1, retVal);
params().iOrdinalPosition=2;
retVal = anim.CommandReply(EADllSetOrdinalPosition,params);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("anim.CommandReply(EADllSetOrdinalPosition,params) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
retVal = group2.OrdinalPosition();
TEST(retVal==1);
if (retVal!=1)
INFO_PRINTF3(_L("group2.OrdinalPosition() return value - Expected: %d, Actual: %d"), 1, retVal);
retVal = group4.OrdinalPosition();
TEST(retVal==2);
if (retVal!=2)
INFO_PRINTF3(_L("group4.OrdinalPosition() return value - Expected: %d, Actual: %d"), 2, retVal);
params().iOrdinalPosition=3;
retVal = anim.CommandReply(EADllSetOrdinalPosition,params);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("anim.CommandReply(EADllSetOrdinalPosition,params) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
retVal = group1.OrdinalPosition();
TEST(retVal==2);
if (retVal!=2)
INFO_PRINTF3(_L("group1.OrdinalPosition() return value - Expected: %d, Actual: %d"), 2, retVal);
retVal = group2.OrdinalPosition();
TEST(retVal==1);
if (retVal!=1)
INFO_PRINTF3(_L("group2.OrdinalPosition() return value - Expected: %d, Actual: %d"), 1, retVal);
retVal = group3.OrdinalPosition();
TEST(retVal==0);
if (retVal!=0)
INFO_PRINTF3(_L("group3.OrdinalPosition() return value - Expected: %d, Actual: %d"), 0, retVal);
retVal = group4.OrdinalPosition();
TEST(retVal==3);
if (retVal!=3)
INFO_PRINTF3(_L("group4.OrdinalPosition() return value - Expected: %d, Actual: %d"), 3, retVal);
params().iOrdinalPriority=priority+1;
params().iOrdinalPosition=3;
retVal = anim.CommandReply(EADllSetOrdinalPosition,params);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("anim.CommandReply(EADllSetOrdinalPosition,params) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
retVal = group4.OrdinalPosition();
TEST(retVal==0);
if (retVal!=0)
INFO_PRINTF3(_L("group4.OrdinalPosition() return value - Expected: %d, Actual: %d"), 0, retVal);
params().iOrdinalPriority=priority;
params().iOrdinalPosition=-2;
retVal = anim.CommandReply(EADllSetOrdinalPosition,params);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("anim.CommandReply(EADllSetOrdinalPosition,params) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
retVal = group4.OrdinalPosition();
TEST(retVal==3);
if (retVal!=3)
INFO_PRINTF3(_L("group4.OrdinalPosition() return value - Expected: %d, Actual: %d"), 3, retVal);
params().iOrdinalPosition=0;
retVal = anim.CommandReply(EADllSetOrdinalPosition,params);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("anim.CommandReply(EADllSetOrdinalPosition,params) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
retVal = group1.OrdinalPosition();
TEST(retVal==3);
if (retVal!=3)
INFO_PRINTF3(_L("group1.OrdinalPosition() return value - Expected: %d, Actual: %d"), 3, retVal);
retVal = group2.OrdinalPosition();
TEST(retVal==2);
if (retVal!=2)
INFO_PRINTF3(_L("group2.OrdinalPosition() return value - Expected: %d, Actual: %d"), 2, retVal);
retVal = group3.OrdinalPosition();
TEST(retVal==1);
if (retVal!=1)
INFO_PRINTF3(_L("group3.OrdinalPosition() return value - Expected: %d, Actual: %d"), 1, retVal);
retVal = group4.OrdinalPosition();
TEST(retVal==0);
if (retVal!=0)
INFO_PRINTF3(_L("group4.OrdinalPosition() return value - Expected: %d, Actual: %d"), 0, retVal);
params().iOrdinalPriority=priority-1;
params().iOrdinalPosition=2;
retVal = anim.CommandReply(EADllSetOrdinalPosition,params);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("anim.CommandReply(EADllSetOrdinalPosition,params) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
retVal = group1.OrdinalPosition();
TEST(retVal==2);
if (retVal!=2)
INFO_PRINTF3(_L("group1.OrdinalPosition() return value - Expected: %d, Actual: %d"), 2, retVal);
retVal = group2.OrdinalPosition();
TEST(retVal==1);
if (retVal!=1)
INFO_PRINTF3(_L("group2.OrdinalPosition() return value - Expected: %d, Actual: %d"), 1, retVal);
retVal = group3.OrdinalPosition();
TEST(retVal==0);
if (retVal!=0)
INFO_PRINTF3(_L("group3.OrdinalPosition() return value - Expected: %d, Actual: %d"), 0, retVal);
retVal = group4.OrdinalPosition();
TEST(retVal==0);
if (retVal!=0)
INFO_PRINTF3(_L("group4.OrdinalPosition() return value - Expected: %d, Actual: %d"), 0, retVal);
params().iOrdinalPriority=priority;
params().iOrdinalPosition=0;
retVal = anim.CommandReply(EADllSetOrdinalPosition,params);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("anim.CommandReply(EADllSetOrdinalPosition,params) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
retVal = group1.OrdinalPosition();
TEST(retVal==3);
if (retVal!=3)
INFO_PRINTF3(_L("group1.OrdinalPosition() return value - Expected: %d, Actual: %d"), 3, retVal);
retVal = group2.OrdinalPosition();
TEST(retVal==2);
if (retVal!=2)
INFO_PRINTF3(_L("group2.OrdinalPosition() return value - Expected: %d, Actual: %d"), 2, retVal);
retVal = group3.OrdinalPosition();
TEST(retVal==1);
if (retVal!=1)
INFO_PRINTF3(_L("group3.OrdinalPosition() return value - Expected: %d, Actual: %d"), 1, retVal);
retVal = group4.OrdinalPosition();
TEST(retVal==0);
if (retVal!=0)
INFO_PRINTF3(_L("group4.OrdinalPosition() return value - Expected: %d, Actual: %d"), 0, retVal);
CleanupStack::PopAndDestroy(5,&anim);
/*TInt pos1=group1.OrdinalPosition();
TInt pos2=group2.OrdinalPosition();
TInt pos3=group3.OrdinalPosition();
TInt pos4=group4.OrdinalPosition();*/
}
/**
@SYMTestCaseID GRAPHICS-WSERV-0139
@SYMDEF DEF081259, DEF122220
@SYMTestCaseDesc Animation's notifications test
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions The test works with two screens. An animation is created that keeps
track on all notifications about EDirectScreenAccess, EHeartbeatTimer,
EScreenDeviceChange events.
The test generates those events by performing operations on direct
screen access and simulating TRawEvent::EInactive and TRawEvent::EAactive
events.
@SYMTestExpectedResults The test checks that the animation didn't miss any of EDirectScreenAccess
or EHeartbeatTimer notifications. (The test doesn't check EScreenDeviceChange
notifications however).
The test also makes sure that the animation didn't animate
during inactive state.
For DEF12220, the test will crash when a untidied notifier from a previous RTestAnim object
is accessed if the fix is not present. If the fix is present, the test should not crash.
*/
void CTAnimDll::TestNotificationsL()
{
RTestAnim anim(iAnimDll);
User::LeaveIfError(anim.Construct(*iRedrawWin->BaseWin(),EAnimTypeNotificationTest,KNullDesC8));
CleanupClosePushL(anim);
TPckgBuf<TInt> screenNum;
// initial state - test that we have no DSA on either screen
screenNum() = 0;
TInt dsa=anim.CommandReply(EADllQueryDSA, screenNum);
TEST(!dsa);
if (dsa)
INFO_PRINTF3(_L("anim.CommandReply(EADllQueryDSA, screenNum) return value - Expected: %d, Actual: %d"), 0, dsa);
screenNum() = 1;
dsa=anim.CommandReply(EADllQueryDSA, screenNum);
TEST(!dsa);
if (dsa)
INFO_PRINTF3(_L("anim.CommandReply(EADllQueryDSA, screenNum) return value - Expected: %d, Actual: %d"), 0, dsa);
// create first DSA, but don't start it - test that we have no DSA on either screen
CScrollText* dsa1 = CScrollText::NewL(iTest->iScreenNumber,1,*TheClient->iGroup,5,EFalse);
CleanupStack::PushL(dsa1);
screenNum() = 0;
dsa=anim.CommandReply(EADllQueryDSA, screenNum);
TEST(!dsa);
if (dsa)
INFO_PRINTF3(_L("anim.CommandReply(EADllQueryDSA, screenNum) return value - Expected: %d, Actual: %d"), 0, dsa);
screenNum() = 1;
dsa=anim.CommandReply(EADllQueryDSA, screenNum);
TEST(!dsa);
if (dsa)
INFO_PRINTF3(_L("anim.CommandReply(EADllQueryDSA, screenNum) return value - Expected: %d, Actual: %d"), 0, dsa);
// start first DSA - test that we have DSA on this screen but not other screen
dsa1->StartL();
screenNum() = 0;
dsa=anim.CommandReply(EADllQueryDSA, screenNum);
TInt retVal = (screenNum() == iTest->iScreenNumber);
TEST(dsa == retVal);
if (dsa != retVal)
INFO_PRINTF3(_L("dsa == (screenNum() == iTest->iScreenNumber) - Expected: %d, Actual: %d"), retVal, dsa);
screenNum() = 1;
dsa=anim.CommandReply(EADllQueryDSA, screenNum);
retVal = (screenNum() == iTest->iScreenNumber);
TEST(dsa == retVal);
if (dsa != retVal)
INFO_PRINTF3(_L("dsa == (screenNum() == iTest->iScreenNumber) - Expected: %d, Actual: %d"), retVal, dsa);
// start second DSA
CScrollText* dsa2 = CScrollText::NewL(iTest->iScreenNumber,2,*TheClient->iGroup,5,EFalse);
CleanupStack::PushL(dsa2);
dsa2->StartL();
screenNum() = 0;
dsa=anim.CommandReply(EADllQueryDSA, screenNum);
retVal = (screenNum() == iTest->iScreenNumber);
TEST(dsa == retVal);
if (dsa != retVal)
INFO_PRINTF3(_L("dsa == (screenNum() == iTest->iScreenNumber) - Expected: %d, Actual: %d"), retVal, dsa);
screenNum() = 1;
dsa=anim.CommandReply(EADllQueryDSA, screenNum);
retVal = (screenNum() == iTest->iScreenNumber);
TEST(dsa == retVal);
if (dsa != retVal)
INFO_PRINTF3(_L("dsa == (screenNum() == iTest->iScreenNumber) - Expected: %d, Actual: %d"), retVal, dsa);
// stop second DSA
dsa2->Stop();
CleanupStack::PopAndDestroy(dsa2);
screenNum() = 0;
dsa=anim.CommandReply(EADllQueryDSA, screenNum);
retVal = (screenNum() == iTest->iScreenNumber);
TEST(dsa == retVal);
if (dsa != retVal)
INFO_PRINTF3(_L("dsa == (screenNum() == iTest->iScreenNumber) - Expected: %d, Actual: %d"), retVal, dsa);
screenNum() = 1;
dsa=anim.CommandReply(EADllQueryDSA, screenNum);
retVal = (screenNum() == iTest->iScreenNumber);
TEST(dsa == retVal);
if (dsa != retVal)
INFO_PRINTF3(_L("dsa == (screenNum() == iTest->iScreenNumber) - Expected: %d, Actual: %d"), retVal, dsa);
// stop first DSA
dsa1->Stop();
CleanupStack::PopAndDestroy(dsa1);
screenNum() = 0;
dsa=anim.CommandReply(EADllQueryDSA, screenNum);
TEST(!dsa);
if (dsa)
INFO_PRINTF3(_L("anim.CommandReply(EADllQueryDSA, screenNum) return value - Expected: %d, Actual: %d"), 0, dsa);
screenNum() = 1;
dsa=anim.CommandReply(EADllQueryDSA, screenNum);
TEST(!dsa);
if (dsa)
INFO_PRINTF3(_L("anim.CommandReply(EADllQueryDSA, screenNum) return value - Expected: %d, Actual: %d"), 0, dsa);
// TEST heartbeat timer start\stop notifications - no longer relevant - has been removed
CleanupStack::PopAndDestroy(&anim);
// Create second RTestAnim for DEF12220 test
RTestAnim anim2(iAnimDll);
User::LeaveIfError(anim2.Construct(*iRedrawWin->BaseWin(),EAnimTypeNotificationTest,KNullDesC8));
CleanupClosePushL(anim2);
// Create third dsa
CScrollText* dsa3 = CScrollText::NewL(iTest->iScreenNumber,1,*TheClient->iGroup,5,EFalse);
CleanupStack::PushL(dsa3);
// If the fix for DEF12220 is not present, starting dsa3 will cause a crash.
dsa3->StartL();
dsa3->Stop();
CleanupStack::PopAndDestroy(dsa3);
CleanupStack::PopAndDestroy(&anim2);
}
/**
A minimal dsa call to a window with a child window, for running coverage on
ClipWindows member funcion.
@SYMTestCaseID GRAPHICS-WSERV-0410
@SYMPREQ PREQ1841
@SYMTestExpectedResults Nothing visible, the CWsClientWindow::ClipWindows
should be partially covered.
*/
void CTAnimDll::TestCoverageL()
{
// create first DSA, but don't start it - test that we have no DSA on either screen
CWindowWithChild* dsa1 = CWindowWithChild::NewL(iTest->iScreenNumber, *TheClient->iGroup, EFalse);
CleanupStack::PushL(dsa1);
// start first DSA - test that we have DSA on this screen but not other screen
dsa1->StartL();
dsa1->PerformCoverageCalls();
dsa1->Stop();
// cover another trivial case for a non-visible window
RWindow* cwin = dsa1->ChildWindow();
cwin->SetTransparencyAlphaChannel();
dsa1->ContinueL();
//ClipWindows with visible and invisible branches
cwin->SetVisible(EFalse);
//cover CWsWindow::StatusDump (visible and invisible branch)
TheClient->iWs.LogCommand(RWsSession::ELoggingStatusDump);
dsa1->Stop();
dsa1->StartL();
cwin->SetVisible(ETrue);
dsa1->Stop();
CleanupStack::PopAndDestroy(dsa1);
}
/**
Executes a Panic coverage test for a given test-number.
Most of the first lines copied from DoPanicTest.
CWsWindow is tested through CommandL (case 0-3) and other API funcs
*/
LOCAL_C TInt DoPanicTestCoverage(TInt aTestNum, TAny *aScreenNumber)
{
RWsSession ws;
User::LeaveIfError(ws.Connect());
// assign to the correct screen
CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws);
User::LeaveIfError(screen->Construct(reinterpret_cast<TInt>(aScreenNumber)));
RWindowGroup group(ws);
User::LeaveIfError(group.Construct(333));
group.EnableReceiptOfFocus(EFalse); // Stop auto group switching on close
RAnimDll animDll=RAnimDll(ws);
User::LeaveIfError(animDll.Load(KAnimDLLName));
RWindow window(ws);
User::LeaveIfError(window.Construct(group,123));
window.SetSize(TSize(10,10));
window.Activate();
window.BeginRedraw();
window.EndRedraw();
switch (aTestNum)
{
case 0: //non translucent window
//EWsWinOpSetTransparentRegion -> EWservPanicTransparencyObjNotCreated
{
RRegion r;
window.SetTransparentRegion(r);
break;
}
case 1:
//EWsWinOpSetTransparencyPolicy -> EWservPanicTransparencyObjNotCreated
window.SetTransparencyPolicy(ETransparencyDefault);
break;
case 2:
// -> EWservPanicWindowActive
window.Activate();
break;
case 3:
// -> EWservPanicCornerParams
window.SetCornerType(EWindowCornerSquare, ECornerTypeMask);
break;
case 4:
// -> EWservPanicCornerParams
window.SetCornerType(ECornerTypeMask, 0);
break;
default:
return EWsExitReasonFinished;
}
ws.Flush();
return(EWsExitReasonBad); // Should never get here, but it's baaddd if it does
}
/**
@SYMTestCaseID GRAPHICS-WSERV-0411
@SYMPREQ PREQ1841
@SYMTestCaseDesc Does functional coverage for code that Panics
*/
void CTAnimDll::TestPanicCoverageL()
{
TClientPanic expectedPanicCode[] =
{
EWservPanicTransparencyObjNotCreated, //0
EWservPanicTransparencyObjNotCreated, //1
EWservPanicWindowActive, //2
EWservPanicCornerParams, //3
EWservPanicCornerParams, //4
};
for (TInt i=0; i<sizeof(expectedPanicCode)/sizeof(TClientPanic); i++)
{
TEST(iTest->TestWsPanicL(
DoPanicTestCoverage, //aFunction
expectedPanicCode[i], //aExitReason
i, //aInt
(TAny*)iTest->iScreenNumber, //aPtr
NULL)); //&finishTests //aTestFinished
iTest->CloseAllPanicWindows();
}
}
/**
@SYMTestCaseID GRAPHICS-CODEBASE-WSERV-0056-0001
@SYMPREQ PGM027
@SYMTestCaseDesc Tests RAnimDll::Load (by passing invalid file name)
@SYMTestPriority 1
@SYMTestStatus Implemented
@SYMTestActions Call RAnimDll::Load() by passing invalid file name\n
@SYMTestExpectedResults Should return with appropiate error message. KErrNotFound
*/
void CTAnimDll::TestLoadApiL()
{
RAnimDll* animDll=new(ELeave) RAnimDll(TheClient->iWs);
CleanupStack::PushL(animDll);
TInt ret=0;
_LIT(KAnimFile,"Nothing.dll");
_LIT(KEmpty,"");
ret=animDll->Load(KAnimFile);
TEST(ret==KErrNotFound);
ret=animDll->Load(KEmpty);
TEST(ret==KErrNotFound);
CleanupStack::PopAndDestroy(animDll);
}
TInt CTAnimDll::CheckError(TInt aError,TInt aExpected)
{
if (aError!=0)
{
if (aError>0)
{
_LIT(KLog,"The event at position %d did not match, total number of events=%d");
LOG_MESSAGE3(KLog,aError,aExpected);
}
else
{
_LIT(KLog,"Only recieved %d events, expecting %d events");
LOG_MESSAGE3(KLog,-aError,aExpected);
}
return EFalse;
}
return ETrue;
}
/**
@SYMTestCaseID GRAPHICS-WSERV-0448
@SYMCR CR1164
@SYMTestCaseDesc Test events get to Anims at a higher priorty than commands
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Create a 2nd thread that sends events via kernal, send also commands from client to an Anim
@SYMTestExpectedResults Check that events intersperse commands from client
*/
void CTAnimDll::KeyClickPriorityL()
{
_LIT(KFailedAdd,"Device Driver Failed to Add an Event, error=%d");
REventAnim* anim=REventAnim::NewL(iTestWin->BaseWin(),&iAnimDll);
TPckgBuf<TInt> events;
TInt err=anim->CommandReply(EADllLoadDeviceDriver);
if (err!=KErrNone)
{
_LIT(KLog,"Failed to load Device Driver for sending Events");
TEST(EFalse);
LOG_MESSAGE(KLog);
}
TInt error;
TInt ii;
for (ii=1;ii<5;++ii)
{
events()=ii;
error=anim->CommandReply(EADllSendEvent,events);
if (error!=KErrNone)
LOG_MESSAGE2(KFailedAdd,error);
anim->Command(EADllAfterEvent);
TheClient->Flush();
error=anim->TestFail(ii);
TEST(CheckError(error,ii));
}
const TInt iterations=15;
const TInt eventsPerIteration=2;
const TInt totalEvents=iterations*eventsPerIteration;
events()=eventsPerIteration;
for (ii=iterations;ii>0;--ii)
{
error=anim->CommandReply(EADllSendEvent,events);
if (error!=KErrNone)
LOG_MESSAGE2(KFailedAdd,error);
anim->Command(EADllAfterEvent);
}
TheClient->Flush();
error=anim->TestFail(totalEvents);
TEST(CheckError(error,totalEvents));
anim->CommandReply(EADllUnloadDeviceDriver);
delete anim;
}
/**
@SYMDEF INC117828
@SYMTestCaseDesc Tests Window Rect returned by CWsAnim::Parameters
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions This test creates a new window which overlaps the screen edge
and creates an animation on this window. An additional
CommandReplyL() option has been added to the AnimDLL to compare
the expected value of this rect with the actual value.
@SYMTestExpectedResults The result of the EADllTestParameterRect CommandReplyL call will equal ETrue
if the passed Rect matches, EFalse otherwise.
*/
void CTAnimDll::ParameterValueTestL()
{
//Window Location & Dimension
TPoint winOrigin(-1,15);
TSize winSize(250,65);
//Create a new window to perform the test; window needs to overlap the left edge of the screen.
CAnimWindow* paramTestWin = new(ELeave) CAnimWindow(EFalse, CAnimWindow::ERedraw);
CleanupStack::PushL(paramTestWin);
paramTestWin->ConstructL(winOrigin, winSize);
RTestAnim anim = RTestAnim(iAnimDll);
TPckgBuf<TRect> rectPckg;
TRect winRect(winOrigin, winSize);
rectPckg() = winRect;
anim.Construct(*(paramTestWin->BaseWin()), EAnimTypeTest3, rectPckg);
anim.Command(EADllStartAnimate, rectPckg);
TPckgBuf<TBool> boolPckg;
boolPckg() = ETrue;
anim.Command(EADllSetVisible, boolPckg);
TEST(anim.CommandReply(EADllParameterRectValueTest, rectPckg));
boolPckg() = EFalse;
anim.Command(EADllSetVisible, boolPckg);
anim.Command(EADllCancelAnimate);
anim.Close();
CleanupStack::PopAndDestroy(paramTestWin);
}
/**
@SYMDEF DEF122176
@SYMTestCaseDesc Test the operation of SetInterval with both negative and positive intervals
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions This test uses the test anim CAutoAnim3 in mode 3 which alternates
between drawing a large and a small ellipse at each interval.
The large ellipse is drawn first.
Note that the anims are redrawn at the rate of 2 intervals per second, so
setting an interval of 2 will mean that the anim is redrawn every second.
Step 1: The interval is set to be -2 and the test then waits for 0.9
seconds (to make sure one interval has passed) then checks that
only the large ellipse has been drawn.
Step 2: The interval is set to be 2 (redraw every second) and the test then
waits for 1.2 seconds (to make sure two intervals have passed) and
checks that the small ellipse has been drawn.
@SYMTestExpectedResults
After Step 1 a large ellipse will be drawn on both windows.
After Step 1 a small ellipse will be drawn on both windows.
*/
void CTAnimDll::TestSetIntervalL()
{
RWsSession ws;
User::LeaveIfError(ws.Connect());
// draws a little circle on the base window using window graphics and using window animation on the test window.
RTestAnim drawAnim=RTestAnim(iAnimDll);
_LIT(KLog1,"SetInterval Test");
LOG_MESSAGE(KLog1);
TRect rect(10,10,110,110);
CAnimWindow::SetEllipseDrawMode(CGraphicsContext::EDrawModePEN);
iTestWin->Invalidate();
iTestWin->SetRect(rect);
iBaseWin->Invalidate();
iBaseWin->SetRect(rect);
TPckgBuf<TRect> rectPckg;
rectPckg()=rect;
User::LeaveIfError(drawAnim.Construct(*iTestWin->BaseWin(),EAnimTypeTest3,rectPckg));
TPckgBuf<TInt> intPckg;
intPckg() = 3; // mode 3 for this anim flips between drawing a large and a small ellipse
drawAnim.Command(EADllSetMode, intPckg);
intPckg() = MAnimGeneralFunctions::ESyncNone;
drawAnim.CommandReply(EADllDoSetSync, intPckg);
// Set an interval of -2 then wait 0.9 seconds, after which only the large ellipse should be visible
intPckg() = -2;
drawAnim.CommandReply(EADllSetInterval, intPckg);
// Draw the large ellipse on the base window to match what the anim should be drawing
iBaseWin->SetRect(rect);
iBaseWin->DoDraw();
ws.Finish();
// Check Step 1 completed successfully
RedrawAndCheckWindows();
// Set an interval of 2 and wait 0.9 seconds, after which the small ellipse should be visible
intPckg() = 2;
drawAnim.CommandReply(EADllSetInterval, intPckg);
// Draw the small ellipse on the base window to match what the anim should be drawing
iBaseWin->SetRect(TRect(40,40,80,80));
iBaseWin->DoDraw();
ws.Finish();
// Check Step 2 completed successfully
RedrawAndCheckWindows();
// clean up
drawAnim.Close();
ws.Close();
}
void CTAnimDll::RunTestCaseL(TInt /*aCurTestCase*/)
{
_LIT(KTest0,"RemoteBuffer");
_LIT(KTest1,"ExtraCopyTest");
_LIT(KTest2,"Misc");
_LIT(KTest3,"SyncMode1");
_LIT(KTest4,"Anim Dll Panics");
_LIT(KTest5,"Drawing test");
_LIT(KTest6,"Shadow drawing test");
_LIT(KTest7,"General drawing test");
_LIT(KTest8,"Destroy window test");
_LIT(KTest9,"Sprite Anim test");
_LIT(KTest10,"Free Timer test");
_LIT(KTest11,"Disable Timer test");
_LIT(KTest12,"Multiple Anims");
_LIT(KTest13,"ReLoad Click PlugIn");
_LIT(KTest14,"Window Functions");
_LIT(KTest15,"Window Functions 2");
_LIT(KTest16,"Notifications");
_LIT(KTest17,"Event Handler removal");
_LIT(KTest18,"Anim dll - Load Api Negative Test");
_LIT(KTest19,"Key Click Priority Test");
_LIT(KTest20,"CWsAnim::Parameters() WindowRect Value Test");
_LIT(KTest21,"SetInterval test");
_LIT(KTest22,"Client Window Coverage");
_LIT(KTest23,"Client Window Panic Coverage");
((CTAnimDllStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
// if (iTest->iState==0) iTest->iState=22; //Use this line to start running tests from a particular test
switch(++iTest->iState)
{
case 1:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0127"));
iTest->LogSubTest(KTest0);
RemoteBuffer();
break;
case 2:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0128"));
iTest->LogSubTest(KTest1);
ExtraCopyTest();
break;
case 3:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0126"));
iTest->LogSubTest(KTest2);
Misc();
break;
case 4:
/**
@SYMTestCaseID GRAPHICS-WSERV-0503
*/
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0503"));
iTest->LogSubTest(KTest3);
// Disabled temporarily (process isolation/ RThread::RequestComplete issue) to allow WSERV test to continue
break;
case 5:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0125"));
iTest->LogSubTest(KTest4);
TestPanicsL();
if (iTest->iScreenNumber == 1)
iTest->CloseAllPanicWindows();
break;
case 6:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0129"));
iTest->LogSubTest(KTest5);
DrawingTestL();
break;
case 7:
/**
@SYMTestCaseID GRAPHICS-WSERV-0504
*/
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0504"));
iTest->LogSubTest(KTest6);
// Disabled temporarily (process isolation/ RThread::RequestComplete issue) to allow WSERV test to continue
break;
case 8:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0130"));
iTest->LogSubTest(KTest7);
GeneralDrawingTestL();
break;
case 9:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0131"));
iTest->LogSubTest(KTest8);
DestroyWindowTestL();
break;
case 10:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0132"));
iTest->LogSubTest(KTest9);
SpriteAnimL();
break;
case 11:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0133"));
iTest->LogSubTest(KTest10);
FreeTimerL();
break;
case 12:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0134"));
iTest->LogSubTest(KTest11);
DisableTimerL();
break;
case 13:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0135"));
iTest->LogSubTest(KTest12);
MultipleAnimsL();
break;
case 14:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0136"));
iTest->LogSubTest(KTest13);
ClickPlugInL();
break;
case 15:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0137"));
iTest->LogSubTest(KTest14);
WinFunctionsL();
break;
case 16:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0138"));
iTest->LogSubTest(KTest15);
WinFunctions2L();
break;
case 17:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0139"));
iTest->LogSubTest(KTest16);
TestNotificationsL();
break;
case 18:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0137"));
iTest->LogSubTest(KTest17);
TestEventHandlerRemovalL();
break;
case 19:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-CODEBASE-WSERV-0056-0001"));
iTest->LogSubTest(KTest18);
TestLoadApiL();
break;
case 20:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0448"));
iTest->LogSubTest(KTest19);
KeyClickPriorityL();
break;
case 21:
/**
@SYMTestCaseID GRAPHICS-WSERV-0505
*/
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0505"));
iTest->LogSubTest(KTest20);
ParameterValueTestL();
break;
case 22:
/**
@SYMTestCaseID GRAPHICS-WSERV-0506
*/
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0506"));
iTest->LogSubTest(KTest21);
TestSetIntervalL();
case 23:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0410"));
iTest->LogSubTest(KTest22);
TestCoverageL();
break;
case 24:
((CTAnimDllStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0411"));
iTest->LogSubTest(KTest23);
TestPanicCoverageL();
default:
((CTAnimDllStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
((CTAnimDllStep*)iStep)->CloseTMSGraphicsStep();
TestComplete();
}
User::Check();
((CTAnimDllStep*)iStep)->RecordTestResultL();
}
//
CAnimRedrawWindow::CAnimRedrawWindow(CAnimWindow *aAnimWindow, TBool aIsBase) : CTWin(),
iAnimWindow(aAnimWindow),
iIsBase(aIsBase)
{
}
CAnimRedrawWindow::~CAnimRedrawWindow()
{
}
void CAnimRedrawWindow::Draw()
{
CAnimWindow::Draw(Gc(),Size(),iIsBase,iAnimWindow->iRect,EFalse);
}
//
CAnimWindow::CAnimWindow(TBool aIsBase, TWinType aWinType) : iWinType(aWinType), iIsBase(aIsBase)
{
}
CAnimWindow::~CAnimWindow()
{
delete iCtWin;
}
void CAnimWindow::ConstructL(const TPoint &aPos, const TSize &aSize)
{
switch(iWinType)
{
case ERedraw:
iCtWin=new(ELeave) CAnimRedrawWindow(this, iIsBase);
break;
case EBlank:
iCtWin=new(ELeave) CTBlankWindow();
break;
case EBackedUp:
iCtWin=new(ELeave) CTBackedUpWin(EGray4);
break;
}
iCtWin->SetUpL(aPos, aSize, TheClient->iGroup, *TheClient->iGc);
if (iWinType==ERedraw)
{
static_cast<CTWin*>(iCtWin)->Win()->EnableRedrawStore(EFalse);
}
}
void CAnimWindow::SetEllipseDrawMode(CGraphicsContext::TDrawMode aEllipseDrawMode)
{
iEllipseDrawMode=aEllipseDrawMode;
}
void CAnimWindow::SetRect(const TRect &aRect)
{
iRect=aRect;
}
void CAnimWindow::DrawEllipse(CBitmapContext *aGc, const TRect &aRect)
{
aGc->SetDrawMode(iEllipseDrawMode);
aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
aGc->SetBrushColor(TRgb(85,85,85));
aGc->SetPenColor(TRgb(170,170,170));
aGc->DrawEllipse(aRect);
}
void CAnimWindow::Draw(CBitmapContext *aGc, const TSize &aSize, TBool aIsBase, const TRect &aRect, TBool aBlankIt)
{
aGc->SetBrushColor(TRgb::Gray4(2));
aGc->Clear();
if (!aBlankIt)
for(TInt i=0;i<aSize.iWidth;i+=10)
aGc->DrawLine(TPoint(i,0),TPoint(i+10,aSize.iHeight));
if (aIsBase)
DrawEllipse(aGc, aRect);
}
void CAnimWindow::DoDraw(TBool aBlankIt)
{
__ASSERT_ALWAYS(iWinType!=EBlank,AutoPanic(EAutoPanicWindowType));
iCtWin->Gc()->Activate(*(RDrawableWindow *)BaseWin());
Draw(iCtWin->Gc(),Size(),iIsBase,iRect,aBlankIt);
iCtWin->Gc()->Deactivate();
}
void CAnimWindow::DoDrawEllipse()
{
__ASSERT_ALWAYS(iWinType!=EBlank,AutoPanic(EAutoPanicWindowType));
iCtWin->Gc()->Activate(*(RDrawableWindow *)BaseWin());
DrawEllipse(iCtWin->Gc(),iRect);
iCtWin->Gc()->Deactivate();
}
void CAnimWindow::DoDrawCoverage()
{
__ASSERT_ALWAYS(iWinType!=EBlank,AutoPanic(EAutoPanicWindowType));
CWindowGc *gc = iCtWin->Gc();
gc->Activate(*(RDrawableWindow *)BaseWin());
gc->SetClippingRect(iRect);
gc->Clear();
gc->Clear(iRect);
gc->SetDrawMode(CGraphicsContext::EDrawModeAND);
gc->SetBrushStyle(CGraphicsContext::ENullBrush);
gc->SetBrushColor(TRgb::Gray256(85));
gc->SetBrushOrigin(TPoint(0,0));
gc->SetPenColor(TRgb::Gray256(170));
//primitive method calls
gc->SetFaded(ETrue);
gc->SetFadingParameters(1, 1);
gc->SetPenStyle(CGraphicsContext::ESolidPen);
gc->SetStrikethroughStyle(EStrikethroughOff);
gc->SetUnderlineStyle(EUnderlineOff);
gc->SetWordJustification(2, 1);
CFbsFont* font;
gc->Device()->GetNearestFontInTwips((CFont*&)font, TFontSpec());
gc->UseFont(font);
gc->DrawArc(iRect,
TPoint(iRect.Center().iX, iRect.iTl.iY),
TPoint(iRect.iBr.iX, iRect.Center().iY));
gc->DrawLine(iRect.iTl,iRect.Center());
gc->DrawLineTo(TPoint(iRect.iBr.iX, iRect.iTl.iY));
gc->DrawLineBy(TPoint(iRect.iTl.iX, iRect.iBr.iY));
gc->MoveBy(iRect.iTl + TPoint(1,1));
gc->MoveTo(iRect.iTl + TPoint(0,0));
gc->SetPenSize(TSize(10,10));
gc->Plot(iRect.iTl + TPoint(2,2));
gc->SetPenSize(TSize(1,1));
CArrayFixFlat<TPoint>* polyPoints = new(ELeave) CArrayFixFlat<TPoint>(3); //CArrayFixFlat
CleanupStack::PushL(polyPoints);
polyPoints->AppendL(iRect.iTl);
polyPoints->AppendL(iRect.Center());
polyPoints->AppendL(TPoint(iRect.iBr.iX, iRect.iTl.iY));
gc->DrawPolyLine(polyPoints);
gc->DrawPolyLine(&polyPoints->At(0), 3);
gc->DrawPolygon(polyPoints, CGraphicsContext::EWinding);
gc->DrawPolygon(&polyPoints->At(0), 3, CGraphicsContext::EAlternate);
gc->DrawPie(iRect, TPoint(iRect.Center().iX, iRect.iTl.iY), TPoint(iRect.iBr.iX, iRect.Center().iY));
gc->DrawEllipse(iRect);
gc->DrawRect(iRect);
gc->DrawRoundRect(iRect, TSize(iRect.Width()/8, iRect.Height()/8));
CleanupStack::PopAndDestroy(polyPoints);
gc->CopyRect(TPoint(10, 10), iRect);
CFbsBitmap* bitmap = new(ELeave) CFbsBitmap();
CleanupStack::PushL(bitmap);
User::LeaveIfError(bitmap->Create(TSize(16,16),EGray4));
gc->UseBrushPattern(bitmap);
gc->DrawBitmap(iRect.iTl, bitmap);
gc->DrawBitmap(iRect, bitmap);
gc->DrawBitmap(iRect, bitmap, TRect(0, 0, 16, 16));
gc->DrawBitmapMasked(iRect, bitmap, TRect(0, 0, 16, 16), bitmap, ETrue);
gc->BitBlt(TPoint(0, 0), bitmap);
gc->BitBlt(TPoint(0, 0), bitmap, iRect);
gc->BitBltMasked(TPoint(0, 0), bitmap, iRect, bitmap, ETrue);
gc->AlphaBlendBitmaps(TPoint(0, 0), bitmap, iRect, bitmap, TPoint(0,0));
CleanupStack::PopAndDestroy(bitmap);
_LIT(KHelloWorld,"Hello World");
gc->SetCharJustification(1,1);
gc->SetClippingRect(iRect);
gc->DrawText(*&KHelloWorld, iRect.iTl);
gc->DrawText(*&KHelloWorld, iRect, 0, CGraphicsContext::ELeft, 0);
gc->DrawTextVertical(*&KHelloWorld, iRect.iBr, ETrue);
gc->DrawTextVertical(*&KHelloWorld, iRect, 0, ETrue, CGraphicsContext::ELeft, 0);
TRgb rgbs[2];
gc->MapColors(iRect, rgbs, 1, ETrue);
gc->DiscardBrushPattern();
gc->DiscardFont();
gc->Device()->ReleaseFont(font);
gc->Deactivate();
}
TSize CAnimWindow::Size()
{
return(iCtWin->Size());
}
RWindowBase *CAnimWindow::BaseWin() const
{
return(iCtWin->BaseWin());
}
CTBaseWin *CAnimWindow::CtBaseWin()
{
return(iCtWin);
}
void CAnimWindow::Invalidate()
{
CTUser::Splat(TheClient,TRect(iCtWin->Position(),iCtWin->Size()),TRgb::Gray256(0));
}
void CAnimWindow::Invalidate(const TRect &aRect)
{
TRect rect(aRect);
rect.Move(iCtWin->Position());
CTUser::Splat(TheClient,rect,TRgb::Gray256(0));
}
void CAnimWindow::DrawTestScreen(CFbsBitmap *aBitmap, CFbsBitmap *aMaskBitmap, CFbsFont *aFont)
{
iCtWin->Gc()->Activate(*(RDrawableWindow *)BaseWin());
CBitmapContext *gc=iCtWin->Gc();
TSize size(Size());
TBool aExtraDrawBitMap=ETrue;
//
#include "DLLDRAW.H"
//
iCtWin->Gc()->Deactivate();
}
__WS_CONSTRUCT_STEP__(AnimDll)