1 // Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Client side of AUTODLL test code

    15 // 

    16 //

    17 

    18 /**

    19  @file

    20  @test

    21  @internalComponent - Internal Symbian test code

    22 */

    23 

    24 #include "TAUTODLL.H"

    25 #include "TEVENT.H"

    26 

    27 //#define LOGGING

    28 

    29 //

    30 

    31 

    32 CGraphicsContext::TDrawMode CAnimWindow::iEllipseDrawMode;

    33 

    34 CTAnimDll::CTAnimDll(CTestStep* aStep) : CTWsGraphicsBase(aStep)

    35 	{

    36 	}

    37 

    38 RTestAnim::RTestAnim() : RAnim()

    39 	{

    40 	}

    41 

    42 RTestAnim::RTestAnim(RAnimDll &aDll) : RAnim(aDll)

    43 	{

    44 	}

    45 

    46 LOCAL_C TInt DoPanicTest(TInt aInt, TAny *aScreenNumber)

    47 	{

    48 	RWsSession ws;

    49 	User::LeaveIfError(ws.Connect());

    50 

    51 	// assign to the correct screen

    52 	CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws);

    53 	User::LeaveIfError(screen->Construct((TInt)aScreenNumber));

    54 

    55 	RWindowGroup group(ws);

    56 	User::LeaveIfError(group.Construct(333));

    57 	group.EnableReceiptOfFocus(EFalse);	// Stop auto group switching on close

    58 	RAnimDll animDll=RAnimDll(ws);

    59 	User::LeaveIfError(animDll.Load(KAnimDLLName));

    60 	RTestAnim panic(animDll);

    61 	RWindow window(ws);

    62 	RBlankWindow blankwin(ws);

    63 	if (aInt==16 || aInt==17)	// Use a blank window for this one

    64 		{

    65 		User::LeaveIfError(blankwin.Construct(group,123));

    66 		blankwin.SetSize(TSize(10,10));

    67 		blankwin.Activate();

    68 		User::LeaveIfError(panic.Construct(blankwin,EAnimTypeTest1,TPtrC8()));

    69 		}

    70 	else

    71 		{

    72 		User::LeaveIfError(window.Construct(group,123));

    73 		window.SetSize(TSize(10,10));

    74 		window.Activate();

    75 		window.BeginRedraw();

    76 		window.EndRedraw();

    77 		if (aInt==0)

    78 			User::LeaveIfError(panic.Construct(window,EAnimTypeTest2,TPtrC8()));

    79 		User::LeaveIfError(panic.Construct(window,EAnimTypeTest1,TPtrC8()));

    80 		}

    81 	TPckgBuf<TPoint> dummyParam;

    82 	switch(aInt)

    83 		{

    84 		case 1:

    85 			panic.Command(EADllPanicCallPanic);

    86 			break;

    87 		case 2:

    88 			panic.Command(EADllPanicCallPanic,dummyParam);

    89 			break;

    90 		case 3:

    91 			panic.CommandReply(EADllPanicCallPanic);

    92 			break;

    93 		case 4:

    94 			panic.CommandReply(EADllPanicCallPanic,dummyParam);

    95 			break;

    96 		case 5:

    97 			panic.Command(EADllPanicSetInterval);

    98 			break;

    99 		case 6:

   100 			panic.Command(EADllPanicSetNextInterval);

   101 			break;

   102 		case 7:

   103 			panic.CommandReply(EADllPanicBadFont);

   104 			break;

   105 		case 8:

   106 			panic.CommandReply(EADllPanicBadBitmap);

   107 			break;

   108 		case 9:

   109 			panic.Command(EADllPanicLeave);

   110 			break;

   111 		case 10:

   112 			panic.Command(EADllPanicDoubleActivateGC);

   113 			break;

   114 		case 11:

   115 			panic.Command(EADllPanicDrawRectWithNoGc);

   116 			break;

   117 		case 12:

   118 			panic.Command(EADllPanicDrawTextWithNoFont);

   119 			break;

   120 		case 13:

   121 			panic.Command(EADllPanicLeaveInAnimate);

   122 			ws.Finish();

   123 			panic.CommandReply(EADllBlankOpCode);

   124 			break;

   125 		case 14:

   126 			panic.Command(EADllPanicLeaveInRedraw);

   127 			window.BeginRedraw();

   128 			window.EndRedraw();

   129 			ws.Finish();

   130 			panic.CommandReply(EADllBlankOpCode);

   131 			break;

   132 		case 15:

   133 			ws.TestWrite(animDll.WsHandle(),999,NULL,0);

   134 			break;

   135 		case 16:

   136 			panic.Command(EADllPanicSetVisWithGcActive);

   137 			break;

   138 		case 17:

   139 			panic.CommandReply(EADllPanicSetVisWithGcActiveReply);

   140 			break;

   141 		case 18:

   142 			panic.Command(EADllPanicLeaveInActiveCallback);

   143 			ws.Flush();

   144 			User::After(2000000);

   145 			panic.CommandReply(EADllBlankOpCode);

   146 			break;

   147 		case 19:

   148 			panic.Command(EADllPanicSetClippingRectWithNoGc);

   149 			break;

   150 		case 20:

   151 			panic.CommandReply(EADllPanicSetClippingRegionWithNoGc);

   152 			break;

   153 		case 21:

   154 			panic.Command(EADllPanicCancelClippingRegionWithNoGc);

   155 			break;

   156 		case 22:

   157 			panic.Command(EADllPanicCancelClippingRectWithNoGc);

   158 			break;

   159 		case 23:

   160 			panic.Command(EADllPanicSetDrawModeWithNoGc);

   161 			break;

   162 		case 24:

   163 			panic.Command(EADllPanicUseFontWithNoGc);

   164 			break;

   165 		case 25:

   166 			panic.Command(EADllPanicDiscardFontWithNoGc);

   167 			break;

   168 		case 26:

   169 			panic.Command(EADllPanicSetUnderlineStyleWithNoGc);

   170 			break;

   171 		case 27:

   172 			panic.Command(EADllPanicSetStrikeThoughStyleWithNoGc);

   173 			break;

   174 		case 28:

   175 			panic.Command(EADllPanicSetWordJustificationWithNoGc);

   176 			break;

   177 		case 29:

   178 			panic.Command(EADllPanicSetCharJustificationWithNoGc);

   179 			break;

   180 		case 30:

   181 			panic.Command(EADllPanicSetPenColorWithNoGc);

   182 			break;

   183 		case 31:

   184 			panic.Command(EADllPanicSetPenStyleWithNoGc);

   185 			break;

   186 		case 32:

   187 			panic.Command(EADllPanicSetPenSizeWithNoGc);

   188 			break;

   189 		case 33:

   190 			panic.Command(EADllPanicSetBrushColorWithNoGc);

   191 			break;

   192 		case 34:

   193 			panic.Command(EADllPanicSetBrushStyleWithNoGc);

   194 			break;

   195 		case 35:

   196 			panic.Command(EADllPanicSetBrushOriginWithNoGc);

   197 			break;

   198 		case 36:

   199 			panic.Command(EADllPanicUseBrushPatterWithNoGc);

   200 			break;

   201 		case 37:

   202 			panic.Command(EADllPanicDiscardBrushPatternWithNoGc);

   203 			break;

   204 		case 38:

   205 			panic.Command(EADllPanicSetFadedWithNoGc);

   206 			break;

   207 		case 39:

   208 			panic.Command(EADllPanicSetFadingParametersWithNoGc);

   209 			break;

   210 		case 40:

   211 			panic.Command(EADllPanicDrawArcWithNoGc);

   212 			break;

   213 		case 41:

   214 			panic.Command(EADllPanicDrawPieWithNoGc);

   215 			break;

   216 		case 42:

   217 			panic.Command(EADllPanicDrawLineWithNoGc);

   218 			break;

   219 		case 43:

   220 			panic.Command(EADllPanicDrawLineToWithNoGc);

   221 			break;

   222 		case 44:

   223 			panic.Command(EADllPanicDrawLineByWithNoGc);

   224 			break;

   225 		case 45:

   226 			panic.Command(EADllPanicDrawEllipseWithNoGc);

   227 			break;

   228 		case 46:

   229 			panic.Command(EADllPanicDrawRoundedRecWithNoGc);

   230 			break;

   231 		case 47:

   232 			panic.Command(EADllPanicClearWithRectWithNoGc);

   233 			break;

   234 		case 48:

   235 			panic.Command(EADllPanicClearWithNoGc);

   236 			break;

   237 		case 49:

   238 			panic.Command(EADllPanicBitBltWithNoGc);

   239 			break;

   240 		case 50:

   241 			panic.Command(EADllPanicBitBltWithRectWithNoGc);

   242 			break;

   243 		case 51:

   244 			panic.Command(EADllPanicBitBltMaskedWithNoGc);

   245 			break;

   246 		case 52:

   247 			panic.Command(EADllPanicDrawBitmapPointWithNoGc);

   248 			break;

   249 		case 53:

   250 			panic.Command(EADllPanicDrawBitmapWithNoGc);

   251 			break;

   252 		case 54:

   253 			panic.Command(EADllPanicDrawBitmapRectWithNoGc);

   254 			break;

   255 		case 55:

   256 			panic.Command(EADllPanicDrawBitmapMaskedFbsBitmapWithNoGc);

   257 			break;

   258 		case 56:

   259 			panic.Command(EADllPanicDrawBitmapMaskedWsBitmapWithNoGc);

   260 			break;

   261 		case 57:

   262 			panic.Command(EADllPanicDrawPolyLinePointsWithNoGc);

   263 			break;

   264 		case 58:

   265 			panic.Command(EADllPanicDrawPolyLineArrayWithNoGc);

   266 			break;

   267 		case 59:

   268 			panic.CommandReply(EADllPanicDrawPolygonPointsWithNoGc);

   269 			break;

   270 		case 60:

   271 			panic.CommandReply(EADllPanicDrawPolygonArrayWithNoGc);

   272 			break;

   273 		case 61:

   274 			panic.Command(EADllPanicMoveToWithNoGc);

   275 			break;

   276 		case 62:

   277 			panic.Command(EADllPanicMoveByWithNoGc);

   278 			break;

   279 		case 63:

   280 			panic.Command(EADllPanicPlotWithNoGc);

   281 			break;

   282 		case 64:

   283 			panic.Command(EADllPanicSetOriginWithNoGc);

   284 			break;

   285 		case 65:

   286 			panic.Command(EADllPanicCopyRectWithNoGc);

   287 			break;

   288 		case 66:

   289 			panic.Command(EADllPanicResetWithNoGc);

   290 			break;

   291 		case 67:

   292 			panic.CommandReply(EADllPanicAlphaBlendingBitmapsFbsBitmapWithNoGc);

   293 			break;

   294 		case 68:

   295 			panic.Command(EADllPanicMapColorsWithNoGc);

   296 			break;

   297 		case 69:

   298 			panic.Command(EADllPanicDrawTextWithRectWithNoFont);

   299 			break;

   300 		case 70:

   301 			panic.Command(EADllPanicDrawTextVerticalWithNoFont);

   302 			break;

   303 		case 71:

   304 			panic.Command(EADllPanicDrawTextVerticalWithRectWithNoFont);

   305 			break;

   306 		case 72:

   307 			panic.CommandReply(EADllPanicDevice);

   308 			break;

   309 		case 73:

   310 			panic.Command(EADllPanicInvalidFocusScreenTooBig);

   311 			break;

   312 		case 74:

   313 			panic.Command(EADllPanicInvalidFocusScreenNegative);

   314 			break;

   315 		default:

   316 			return(EWsExitReasonFinished);

   317 		}

   318 

   319 	ws.Flush();

   320 	return(EWsExitReasonBad);

   321 	}

   322 

   323 /**

   324 @SYMTestCaseID		GRAPHICS-WSERV-0125

   325 

   326 @SYMDEF             DEF081259

   327 

   328 @SYMTestCaseDesc    Panic tests

   329 

   330 @SYMTestPriority    High

   331 

   332 @SYMTestStatus      Implemented

   333 

   334 @SYMTestActions     The test creates an animation and animation's client threads.

   335 					Each thread calls some

   336 					command of the animation which is expected to panic on certain reason.

   337 					The test checks that those client threads will panic returning

   338 					a proper panic code. Client threads are created and tested for

   339 					the following actions:

   340 					1. A Command() call to an animation which executes

   341 					iFunctions->Panic() method. Client thread must panic with

   342 					code EWservPanicAnimDll.

   343 					2. A Command() call with dummy parameter to an animation which

   344 					executes iFunctions->Panic() method. Client thread must panic

   345 					with code EWservPanicAnimDll.

   346 					3. A CommandReply() call to an animation which executes

   347 					iFunctions->Panic() method. Client thread must panic with code

   348 					EWservPanicAnimDll.

   349 					4. A CommandReply() call with dummy parameter to an animation

   350 					which executes iFunctions->Panic() method. Client thread must

   351 					panic with code EWservPanicAnimDll.

   352 					5. A command that calls MAnimGeneralFunctions::SetInterval() when

   353 					the synchronisation mode is not TAnimSync::ESyncNone. Client

   354 					thread must panic with code EWservPanicAnimDll.

   355 					6. A command that calls MAnimGeneralFunctions::SetNextInterval()

   356 					when the synchronisation mode is not TAnimSync::ESyncNone. Client

   357 					thread must panic with code EWservPanicAnimDll.

   358 					7. A command that calls MAnimGeneralFunctions::DuplicateFontL() to

   359 					duplicate undefined font. Client thread must panic with code

   360 					EWservPanicFont.

   361 					8. A command that calls MAnimGeneralFunctions::DuplicateBitmapL()

   362 					to duplicate undefined bitmap. Client thread must panic with code

   363 					EWservPanicBitmap.

   364 					9. A command that calls User::Leave(KErrGeneral). Client thread

   365 					must panic with code EWservPanicAnimLeave.

   366 					10. A command that activates window animation's graphical context

   367 					twice. Client thread must panic with code EWservPanicAnimDll.

   368 					11. A command that tries to draw a rectangle while graphical

   369 					context is not defined yet. Client thread must panic with code

   370 					EWservPanicAnimLeave.

   371 					12. A command that tries to draw a text whihout a font defined yet.

   372 					Client thread must panic with code EWservPanicNoFont.

   373 					13. A command that causes an animation to leave during execution

   374 					of CAnim::Animate() method; and a new command call 4 seconds after

   375 					that. Client thread must panic with code EWservPanicAnimLeave.

   376 					14. A command that causes an animation to leave during execution

   377 					of CAnim::Redraw() method. The client thread initiates it's window

   378 					redraw after that. Client thread must panic with code

   379 					EWservPanicAnimLeave.

   380 					15. The client thread calls RWsSession::TestWrite() on animation

   381 					DLL server-side handle with opcode 999. Client thread must panic with code

   382 					EWservPanicOpcode.

   383 					16. A command that activates graphical context and sets the

   384 					window to invisible and then to visible. Client thread must panic

   385 					with code EWservPanicAnimDll.

   386 

   387 

   388 @SYMTestExpectedResults See test actions.

   389 */

   390 void CTAnimDll::TestPanicsL()

   391 	{

   392 	TInt index=0;

   393 	TBool finishTests=EFalse;

   394 	do

   395 		{

   396 

   397 

   398 		TClientPanic panicCode=EWservPanicAnimDll;

   399 		switch(index)

   400 			{

   401 			// panic the server with a KERN-4. When server fixed these this can be removed.

   402 			case 19:

   403 			case 20:

   404 			case 22:

   405 			case 24:

   406 				goto bypasstest;

   407 

   408 			case 0:

   409 			case 1:

   410 			case 2:

   411 			case 3:

   412 			case 4:

   413 			case 5:

   414 			case 6:

   415 			case 10:

   416 			case 16:

   417 			case 17:

   418 			case 18:

   419 			case 73:

   420 			case 74:

   421 				panicCode=EWservPanicAnimDll;

   422 				break;

   423 			case 7:

   424 				panicCode=EWservPanicFont;

   425 				break;

   426 			case 8:

   427 				panicCode=EWservPanicBitmap;

   428 				break;

   429 			case 12:

   430 			case 69:

   431 			case 70:

   432 			case 71:

   433 				panicCode=EWservPanicNoFont;

   434 				break;

   435 			case 15:

   436 				panicCode=EWservPanicOpcode;

   437 				break;

   438 			case 9:

   439 			case 11:

   440 			case 13:

   441 			case 14:

   442 			case 72:

   443 			default: // cases 19 - 68

   444 				panicCode=EWservPanicAnimLeave;

   445 				break;

   446 			}

   447 			

   448 		TEST(iTest->TestWsPanicL(&DoPanicTest,panicCode,index,(TAny*)iTest->iScreenNumber,&finishTests));

   449 bypasstest:

   450 		if (iTest->iScreenNumber == 0)

   451 			iTest->CloseAllPanicWindows();

   452 		index++;

   453 		} while(!finishTests);

   454 	}

   455 

   456 void CTAnimDll::TestSyncModes(MAnimGeneralFunctions::TAnimSync aSyncMode)

   457 	{

   458 	RTestAnim anim=RTestAnim(iAnimDll);

   459 	User::LeaveIfError(anim.Construct(*iTestWin->BaseWin(),EAnimTypeTest1,TPtrC8()));

   460 	CleanupClosePushL(anim);

   461 

   462 	TPckgBuf<TSyncTests> params;

   463 	TRequestStatus status(KRequestPending);

   464 	params().status=&status;

   465 	params().syncMode=aSyncMode;

   466 	anim.CommandReply(EADllSyncTests,params);

   467 	User::WaitForRequest(status);

   468 	TEST(status==KErrNone);

   469 

   470 	CleanupStack::PopAndDestroy(&anim);

   471 	}

   472 

   473 void CTAnimDll::TestTimeChange()

   474 	{

   475 	RTestAnim anim=RTestAnim(iAnimDll);

   476 	User::LeaveIfError(anim.Construct(*iTestWin->BaseWin(),EAnimTypeTest1,TPtrC8()));

   477 	CleanupClosePushL(anim);

   478 

   479 	TPckgBuf<TTimeChangeTest> params;

   480 	TRequestStatus status(KRequestPending);

   481 	TRequestStatus status2(KRequestPending);

   482 	params().status=&status;

   483 	params().status2=&status2;

   484 	anim.CommandReply(EADllTimeChangedTest,params);

   485 	User::WaitForRequest(status);

   486 	TTime time;

   487 	time.HomeTime();

   488 	time+=TTimeIntervalHours(1);

   489 	User::SetHomeTime(time);

   490 	User::WaitForRequest(status2);

   491 	time.HomeTime();

   492 	time-=TTimeIntervalHours(1);

   493 	User::SetHomeTime(time);

   494 	TEST(status2==KErrNone);

   495 

   496 	CleanupStack::PopAndDestroy(&anim);

   497 	}

   498 

   499 void CTAnimDll::ConstructL()

   500 	{

   501 	TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(0);

   502 	iRedrawWin=new(ELeave) CAnimWindow(EFalse, CAnimWindow::ERedraw);

   503 	iBackedUpTestWin=new(ELeave) CAnimWindow(EFalse, CAnimWindow::EBackedUp);

   504 	iBlankTestWin=new(ELeave) CAnimWindow(EFalse, CAnimWindow::EBlank);

   505 	iBaseWin=new(ELeave) CAnimWindow(ETrue, CAnimWindow::ERedraw);

   506 

   507 //

   508 	TSize screenSize=TheClient->iGroup->Size();

   509 	TInt winWidth=(screenSize.iWidth/3)-10;

   510 	TInt winHeight=screenSize.iHeight-10;

   511 	iBaseWin->ConstructL(TPoint(screenSize.iWidth/3+5,5),TSize(winWidth,winHeight));

   512 	iBlankTestWin->ConstructL(TPoint(screenSize.iWidth/3*2+5,5),TSize(winWidth,winHeight));

   513 	((RBlankWindow *)iBlankTestWin->BaseWin())->SetColor(TRgb::Gray4(2));

   514 	iBackedUpTestWin->ConstructL(TPoint(screenSize.iWidth/3*2+5,5),TSize(winWidth,winHeight));

   515 	iRedrawWin->ConstructL(TPoint(screenSize.iWidth/3*2+5,5),TSize(winWidth,winHeight));

   516 //

   517 	iTestWin=iRedrawWin;

   518 //

   519 	iAnimDll=RAnimDll(TheClient->iWs);

   520 	TInt retVal = iAnimDll.Load(KAnimDLLName);

   521 	TEST(retVal==KErrNone);

   522 	if (retVal!=KErrNone)

   523 		INFO_PRINTF3(_L("iAnimDll.Load(KAnimDLLName) return value - Expected: %d , Actual: %d"), KErrNone, retVal);

   524 	}

   525 

   526 CTAnimDll::~CTAnimDll()

   527 	{

   528 	iAnimDll.Close();

   529 	delete iBackedUpTestWin;

   530 	delete iBlankTestWin;

   531 	delete iRedrawWin;

   532 	delete iBaseWin;

   533 	}

   534 

   535 /**

   536 @SYMTestCaseID		GRAPHICS-WSERV-0126

   537 

   538 @SYMDEF             DEF081259

   539 

   540 @SYMTestCaseDesc    Miscellaneous animation tests.

   541 

   542 @SYMTestPriority    High

   543 

   544 @SYMTestStatus      Implemented

   545 

   546 @SYMTestActions     Tests window animation's window funtions like WindowSize(),

   547 					IsHidden(), SetVisible().

   548 					Tests RAnimDll's constructor, Close(), Load() and copy-constructor.

   549 

   550 @SYMTestExpectedResults Expects window funtions and RAnimDll's methods work properly.

   551 */

   552 void CTAnimDll::Misc()

   553 	{

   554 	RTestAnim anim=RTestAnim(iAnimDll);

   555 	User::LeaveIfError(anim.Construct(*iTestWin->BaseWin(),EAnimTypeTest1,TPtrC8()));

   556 	CleanupClosePushL(anim);

   557 

   558 	TPckgBuf<TSize> params;

   559 	params()=iTestWin->Size();

   560 	TBool retBool = anim.CommandReply(EADllTestWindowSize,params);

   561 	TEST(retBool);

   562 	if (!retBool)

   563 		INFO_PRINTF3(_L("anim.CommandReply(EADllTestWindowSize,params) return value - Expected: %d , Actual: %d"), ETrue, retBool);

   564 	TheClient->iWs.Finish();

   565 	retBool = anim.CommandReply(EADllTestSetVisible);

   566 	TEST(retBool);

   567 	if (!retBool)

   568 		INFO_PRINTF3(_L("anim.CommandReply(EADllTestSetVisible) return value - Expected: %d , Actual: %d"), ETrue, retBool);

   569 	CleanupStack::PopAndDestroy(&anim);

   570 

   571 	RAnimDll closeme(TheClient->iWs);

   572 	closeme.Close();

   573 	RAnimDll animdll(TheClient->iWs);

   574 	TInt retVal = animdll.Load(KAnimDLLName);

   575 	TEST(retVal==KErrNone);

   576 	if (retVal!=KErrNone)

   577 		INFO_PRINTF3(_L("animdll.Load(KAnimDLLName) return value - Expected: %d , Actual: %d"), KErrNone, retVal);

   578 

   579 	RTestAnim anim2(animdll);

   580 	anim2.Close();

   581 	animdll.Close();

   582 	}

   583 

   584 /**

   585 @SYMTestCaseID		GRAPHICS-WSERV-0127

   586 

   587 @SYMDEF             DEF081259

   588 

   589 @SYMTestCaseDesc    Test animation's command call with reply

   590 

   591 @SYMTestPriority    High

   592 

   593 @SYMTestStatus      Implemented

   594 

   595 @SYMTestActions     Puts an array containing a sequnce of numbers into a command argument.

   596 					Performs command call to server, assuming that the server-side

   597 					should return a sum of the numbers in sequence.

   598 

   599 @SYMTestExpectedResults Checks that server returns the correct sum.

   600 */

   601 void CTAnimDll::RemoteBuffer()

   602 	{

   603 	RTestAnim anim=RTestAnim(iAnimDll);

   604 	User::LeaveIfError(anim.Construct(*iTestWin->BaseWin(),EAnimTypeTest1,TPtrC8()));

   605 	CleanupClosePushL(anim);

   606 

   607 	TBuf<ERemoteBufSize> buf(ERemoteBufSize);

   608 	TInt total=0;

   609 	for (TInt8 index=0;index<ERemoteBufSize;index++)

   610 		{

   611 		total+=index;

   612 		buf[index]=index;

   613 		}

   614 	TIpcArgs ipcArgs;

   615 	ipcArgs.Set(KIpcSlot,&buf);

   616  	TInt retVal = anim.CommandReply(EADllReadRemoteDescriptor,KNullDesC8,ipcArgs);

   617 	TEST(retVal==total);

   618 	if (retVal!=total)

   619 		INFO_PRINTF3(_L("anim.CommandReply(EADllReadRemoteDescriptor,KNullDesC8,ipcArgs) return value - Expected: %d , Actual: %d"), total, retVal);

   620 

   621 	CleanupStack::PopAndDestroy(&anim);

   622 	}

   623 //

   624 /**

   625 @SYMTestCaseID		GRAPHICS-WSERV-0128

   626 

   627 @SYMDEF             DEF081259

   628 

   629 @SYMTestCaseDesc    RAnimDll extracopy test

   630 

   631 @SYMTestPriority    High

   632 

   633 @SYMTestStatus      Implemented

   634 

   635 @SYMTestActions     Creates another RAnimDll instance for a dll that already has a client-side interface.

   636 

   637 @SYMTestExpectedResults Expects that operation completes without errors.

   638 */

   639 void CTAnimDll::ExtraCopyTest()

   640 	{

   641 	RAnimDll extraCopy(TheClient->iWs);

   642 	TInt retVal = extraCopy.Load(KAnimDLLName);

   643 	TEST(retVal==KErrNone);

   644 	if (retVal!=KErrNone)

   645 		INFO_PRINTF3(_L("extraCopy.Load(KAnimDLLName) return value - Expected: %d , Actual: %d"), KErrNone, retVal);

   646 

   647 	extraCopy.Close();

   648 	}

   649 //

   650 void CTAnimDll::SyncMode1()

   651 	{

   652 	TestSyncModes(MAnimGeneralFunctions::ESyncSecond);

   653 	}

   654 

   655 void CTAnimDll::CheckWindows()

   656 	{

   657 	CheckRect(iBaseWin->CtBaseWin(),iTestWin->CtBaseWin(),TRect(iBaseWin->Size()),_L("CTAnimDll::CheckWindows() failed"));

   658 	}

   659 

   660 void CTAnimDll::InvalidatePauseAndRedraw(const TRect &aRect,TTimeIntervalMicroSeconds32 aInterval)

   661 	{

   662 	iTestWin->Invalidate(aRect);

   663 	TheClient->iWs.Flush();

   664 	User::After(aInterval);

   665 	__ASSERT_DEBUG(iTestWin->iWinType==CAnimWindow::ERedraw,AutoPanic(EAutoPanicWindowType));

   666 	RWindow *win=(RWindow *)iTestWin->BaseWin();

   667 	win->BeginRedraw();

   668 	iTestWin->DoDraw();

   669 	win->EndRedraw();

   670 	TheClient->iWs.Flush();

   671 	}

   672 

   673 void CTAnimDll::RedrawAndCheckWindows(TBool aBlankIt)

   674 	{

   675 	if (iTestWin->iWinType==CAnimWindow::ERedraw)

   676 		{

   677 		RWindow *win=(RWindow *)iTestWin->BaseWin();

   678 		win->BeginRedraw();

   679 		iTestWin->DoDraw(aBlankIt);

   680 		win->EndRedraw();

   681 		}

   682 	RWindow *win=(RWindow *)iBaseWin->BaseWin();

   683 	win->BeginRedraw();

   684 	iBaseWin->DoDraw(aBlankIt);

   685 	win->EndRedraw();

   686 	TheClient->WaitForRedrawsToFinish();

   687 	CheckWindows();

   688 	}

   689 

   690 /**

   691 @SYMTestCaseID		GRAPHICS-WSERV-0129

   692 

   693 @SYMDEF             DEF081259

   694 

   695 @SYMTestCaseDesc    Animation drawing test

   696 

   697 @SYMTestPriority    High

   698 

   699 @SYMTestStatus      Implemented

   700 

   701 @SYMTestActions     Performs animation drawing ontop of redrawable window, backed-up window and blank window.

   702 					Draws the same shapes using directly window graphics on an other window (base window).

   703 					The following shapes are drawn:

   704 					1. An animation with a small ellipse drawn in XOR mode on top of redrawable

   705 					black-lined gray window.

   706 					2. The same with a bigger ellipse but previously invalidating an

   707 					area which intersects the old ellipse and the new ellipse.

   708 					3. Runs an animation that continuously moves a rectangle and shrinks another on top of

   709 					redrawable black-lined gray window and then cancels an animation.

   710 					The test checks that the window will be identical with the gray base window

   711 					that contains only black lines.

   712 					4. An animation with a small ellipse drawn in XOR mode on top of backed-up

   713 					black-lined gray window. The test also calls Invalidate() method and performs

   714 					a check again to make sure that the test-window and base window are identical.

   715 					5. An animation with a small ellipse drawn in XOR mode on top of the blank

   716 					gray window. The test also sends commands to the animation that call windows

   717 					SetVisible(EFalse) and SetVisible(ETrue) and checks that the

   718 					test-window and base window are identical.

   719 

   720 

   721 @SYMTestExpectedResults Each time performs pixelwise comparisons of animated windows

   722 					and the base window expecting the windows to be identical.

   723 */

   724 void CTAnimDll::DrawingTestL()

   725 	{

   726 	// draws a little circle on the base window using window graphics and using window animation on the test window.

   727 	RTestAnim drawAnim=RTestAnim(iAnimDll);

   728 //

   729 	TRect rect;

   730 	TPckgBuf<TRect> rectPckg;

   731 	TPckgBuf<TBool> boolPckg;

   732 

   733 //

   734 	_LIT(KLog1,"Draw Ellipse Test1");

   735 	LOG_MESSAGE(KLog1);

   736 	rect = TRect(10,10,50,50);

   737 	CAnimWindow::SetEllipseDrawMode(CGraphicsContext::EDrawModeXOR);

   738 	iTestWin->Invalidate();

   739 	iTestWin->SetRect(rect);

   740 	iBaseWin->Invalidate();

   741 	iBaseWin->SetRect(rect);

   742 	rectPckg()=rect;

   743 	User::LeaveIfError(drawAnim.Construct(*iTestWin->BaseWin(),EAnimTypeTest3,rectPckg));

   744 	RedrawAndCheckWindows();

   745 //

   746 	_LIT(KLog2,"Draw Ellipse Test2");

   747 	LOG_MESSAGE(KLog2);

   748 	iTestWin->Invalidate(TRect(20,20,100,40));

   749 	iBaseWin->Invalidate(TRect(20,20,100,40));

   750 	iBaseWin->DoDrawEllipse();	// Should clear old Ellipse (except invalid bits)

   751 	rect=TRect(30,30,200,100);

   752 	rectPckg()=rect;

   753 	iBaseWin->SetRect(rect);

   754 	iBaseWin->DoDrawEllipse();	// Should draw new Ellipse (except invalid bits)

   755 	drawAnim.Command(EADllSetRect,rectPckg);

   756 	RedrawAndCheckWindows();

   757 	iBaseWin->DoDrawEllipse();	// Clear old ellipse

   758 //

   759 	_LIT(KLog3,"Window Overlap Anim Test");

   760 	LOG_MESSAGE(KLog3);

   761 

   762 	iBaseWin->SetRect(TRect());

   763 	iBaseWin->DoDraw();

   764 	TheClient->iWs.Finish();

   765 

   766 	// create another window on top and check that animation beneath is not visible	

   767 	TSize screenSize=TheClient->iGroup->Size();

   768 	TInt winWidth=(screenSize.iWidth/3)-10;

   769 	TInt winHeight=screenSize.iHeight-10;

   770 	TSize size=iTestWin->Size();

   771 	rectPckg()=TRect(size);

   772 	drawAnim.Command(EADllStartAnimate,rectPckg);

   773 

   774 	CAnimWindow *topWindow = new (ELeave) CAnimWindow(ETrue, CAnimWindow::ERedraw);

   775 	CleanupStack::PushL(topWindow);

   776 	topWindow->ConstructL(TPoint(screenSize.iWidth/3*2+5,5),TSize(winWidth,winHeight));

   777 	

   778 	RWindow *win=(RWindow *)iTestWin->BaseWin();

   779 	win->BeginRedraw();

   780 	topWindow->DoDraw(EFalse);

   781 	win->EndRedraw();

   782 	

   783 	TheClient->iWs.Flush();

   784 	for(TInt i=0;i<size.iWidth/2;i+=5)

   785 		InvalidatePauseAndRedraw(TRect(i,size.iHeight-i-i,i+i,size.iHeight-i),TTimeIntervalMicroSeconds32(400000));

   786 

   787 	TheClient->WaitForRedrawsToFinish();

   788 	CheckRect(iBaseWin->CtBaseWin(),iTestWin->CtBaseWin(),TRect(iBaseWin->Size()));

   789 	

   790 	win->BeginRedraw(rect);

   791 	drawAnim.Command(EADllCancelAnimate,rectPckg);

   792 	win->EndRedraw();

   793 

   794 	CleanupStack::PopAndDestroy(topWindow);

   795 //

   796 	iTestWin->BaseWin()->SetVisible(EFalse);

   797 	drawAnim.Close();

   798 //

   799 	_LIT(KLog4,"Draw Ellipse Test4&5");

   800 	LOG_MESSAGE(KLog4);

   801 	rect=TRect(20,20,50,50);

   802 	iBackedUpTestWin->SetRect(rect);

   803 	iBackedUpTestWin->DoDraw();

   804 	iBaseWin->SetRect(rect);

   805 	win->BeginRedraw();

   806 	iBaseWin->DoDraw();

   807 	win->EndRedraw();

   808 	TheClient->iWs.Finish();

   809 

   810 	rectPckg()=rect;

   811 	User::LeaveIfError(drawAnim.Construct(*iBackedUpTestWin->BaseWin(),EAnimTypeTest3,rectPckg));

   812 	TheClient->iWs.Finish();

   813 	TheClient->WaitForRedrawsToFinish();

   814 	CheckWindows();

   815 	iBackedUpTestWin->Invalidate();

   816 	TheClient->iWs.Flush();

   817 	TheClient->WaitForRedrawsToFinish();

   818 	CheckWindows();

   819 	iBackedUpTestWin->BaseWin()->SetVisible(EFalse);

   820 //

   821 	_LIT(KLog5,"Draw Ellipse Test6&7");

   822 	LOG_MESSAGE(KLog5);

   823 	rect=TRect(20,20,50,50);

   824 	TheClient->iWs.Flush();

   825 	RWindow *winBase=(RWindow *)iBaseWin->BaseWin();

   826 	winBase->BeginRedraw();

   827 	iBaseWin->SetRect(rect);

   828 	iBaseWin->DoDraw(ETrue);

   829 	winBase->EndRedraw();

   830 	rectPckg()=rect;

   831 	User::LeaveIfError(drawAnim.Construct(*iBlankTestWin->BaseWin(),EAnimTypeTest3,rectPckg));

   832 	TheClient->iWs.Flush();

   833 	iBlankTestWin->Invalidate();

   834 	TheClient->iWs.Flush();

   835 	TheClient->WaitForRedrawsToFinish();

   836 	CheckWindows();

   837 	boolPckg()=EFalse;

   838 	drawAnim.Command(EADllSetVisible,boolPckg);

   839 	TheClient->iWs.Flush();

   840 	boolPckg()=ETrue;

   841 	drawAnim.Command(EADllSetVisible,boolPckg);

   842 	TheClient->WaitForRedrawsToFinish();

   843 	CheckWindows();

   844 

   845 //This test does functional coverage by calling code that executes each of the 

   846 //server's class (CWsAnimGc) members in turn.

   847 

   848 

   849 	_LIT(KLog6,"Draw Primitives (Coverage) Test");

   850 	LOG_MESSAGE(KLog6);

   851 	rect = TRect(10,10,150,150);

   852 	iBaseWin->BaseWin()->SetVisible(ETrue);

   853 	iBaseWin->SetRect(TRect(0,0,0,0));

   854 	winBase->BeginRedraw();

   855 	iBaseWin->DoDraw();

   856 	iBaseWin->SetRect(rect);

   857 	iBaseWin->DoDrawCoverage();

   858 	winBase->EndRedraw();

   859 

   860 	iTestWin->BaseWin()->SetVisible(ETrue);

   861 	iTestWin->SetRect(rect);

   862 	win->BeginRedraw();

   863 	iTestWin->DoDraw();

   864 	win->EndRedraw();

   865 

   866 	rectPckg()=rect;

   867 	User::LeaveIfError(drawAnim.Construct(*iTestWin->BaseWin(),EAnimTypeCoverage,rectPckg));

   868 	

   869 	//set font

   870 	CFbsFont* font;

   871 	User::LeaveIfError(TheClient->iGc->Device()->GetNearestFontToDesignHeightInTwips((CFont*&)font, TFontSpec()));

   872 	TPckgBuf<TInt> fontHandle;

   873 	fontHandle() = font->Handle();

   874 	const TInt err = drawAnim.CommandReply(EADllSetFont, fontHandle);

   875 	TheClient->iGc->Device()->ReleaseFont(font);

   876 	User::LeaveIfError(err);

   877 	

   878 	//draw 

   879 	User::LeaveIfError(drawAnim.CommandReply(EADllDrawNow));

   880 

   881 	TheClient->iWs.Finish();

   882 	TheClient->WaitForRedrawsToFinish();

   883 	CheckWindows();

   884 	drawAnim.Close();

   885 	}

   886 

   887 void CTAnimDll::ShadowDrawingTestL()

   888 	{

   889 // Create a blank window to cast a shadow over the animation

   890 	TSize scrSize(TheClient->iScreen->SizeInPixels());

   891 	CTBlankWindow *blank=new(ELeave) CTBlankWindow();

   892 	CleanupStack::PushL(blank);

   893 	blank->SetUpL(TPoint(0,10), TSize(scrSize.iWidth,scrSize.iHeight/3), TheClient->iGroup, *TheClient->iGc);

   894 	blank->BaseWin()->SetShadowHeight(2);

   895 	iBlankTestWin->BaseWin()->SetShadowHeight(0);

   896 //

   897 	RTestAnim drawAnim=RTestAnim(iAnimDll);

   898 	TRect rect(10,scrSize.iHeight/3-20,50,scrSize.iHeight/3+40);

   899 	TPckgBuf<TRect> rectPckg;

   900 	rectPckg()=rect;

   901 	User::LeaveIfError(drawAnim.Construct(*iBlankTestWin->BaseWin(),EAnimTypeTest3,rectPckg));

   902 	drawAnim.Command(EADllSetShadowDrawMode);

   903 	CAnimWindow::SetEllipseDrawMode(CGraphicsContext::EDrawModePEN);

   904 //

   905 	iBlankTestWin->Invalidate();

   906 	iBlankTestWin->SetRect(rect);

   907 	iBaseWin->Invalidate();

   908 	iBaseWin->SetRect(rect);

   909 	RedrawAndCheckWindows(ETrue);

   910 //

   911 	for(TInt ypos=10;ypos>0;ypos-=4)

   912 		{

   913 		blank->SetPos(TPoint(0,ypos));

   914 		TPckgBuf<TShadowDrawTest> params;

   915 		TRequestStatus status(KRequestPending);

   916 		params().status=&status;

   917 		drawAnim.CommandReply(EADllShadowAnimTest,params);

   918 		User::WaitForRequest(status);

   919 		RedrawAndCheckWindows(ETrue);

   920 		}

   921 //

   922 	CleanupStack::PopAndDestroy(blank);	// Destroy the shadow window

   923 	}

   924 

   925 /**

   926 @SYMTestCaseID		GRAPHICS-WSERV-0130

   927 

   928 @SYMDEF             DEF081259

   929 

   930 @SYMTestCaseDesc    Complicated drawing test

   931 

   932 @SYMTestPriority    High

   933 

   934 @SYMTestStatus      Implemented

   935 

   936 @SYMTestActions     Performs complicated drawing both through the animation on

   937 					a blank window and through direct fbs drawing on the second

   938 					window.

   939 

   940 @SYMTestExpectedResults Expects the both windows to be are identical

   941 */

   942 void CTAnimDll::GeneralDrawingTestL()

   943 	{

   944 	// This test has been removed as it is no longer relevant

   945 	// Anims are not allowed to draw immediately to the screen

   946 	}

   947 

   948 /**

   949 @SYMTestCaseID		GRAPHICS-WSERV-0131

   950 

   951 @SYMDEF             DEF081259

   952 

   953 @SYMTestCaseDesc    Animated window destruction test

   954 

   955 @SYMTestPriority    High

   956 

   957 @SYMTestStatus      Implemented

   958 

   959 @SYMTestActions     Creates a window and a child window inside it, runs an animation

   960 					in the child window in ESyncFlash mode, destroys windows.

   961 

   962 @SYMTestExpectedResults Expects the operations not to fail.

   963 */

   964 void CTAnimDll::DestroyWindowTestL()

   965 	{

   966 	RWindow window(TheClient->iWs);

   967 	User::LeaveIfError(window.Construct(*TheClient->iGroup->GroupWin(),123));

   968 	CleanupClosePushL(window);

   969 	window.SetSize(TSize(100,100));

   970 	window.Activate();

   971 	RWindow window2(TheClient->iWs);

   972 	CleanupClosePushL(window2);

   973 	User::LeaveIfError(window2.Construct(window,124));

   974 	window2.Activate();

   975 	window2.BeginRedraw();	// Validate it

   976 	window2.EndRedraw();

   977 //

   978 	RTestAnim drawAnim;

   979 	drawAnim=RTestAnim(iAnimDll);

   980 	TRect rect(10,10,50,50);

   981 	TPckgBuf<TRect> rectPckg;

   982 	rectPckg()=rect;

   983 	User::LeaveIfError(drawAnim.Construct(window2,EAnimTypeTest3,rectPckg));

   984 	drawAnim.Command(EADllStartAnimate,rectPckg);

   985 	CleanupStack::Pop(&window2);

   986 	CleanupStack::PopAndDestroy(&window);

   987 	TheClient->iWs.Flush();

   988 	User::After(TTimeIntervalMicroSeconds32(2000000));

   989 	window2.Close();

   990 	drawAnim.Close();

   991 	}

   992 

   993 void CTAnimDll::SetUpMember(TSpriteMember &aMember,TInt aType)

   994 	{

   995 	switch (aType)

   996 		{

   997 	case 1:

   998 		iTest->SetUpMember(aMember);

   999 		aMember.iOffset=TPoint();

  1000 		aMember.iInterval=TTimeIntervalMicroSeconds32(1);

  1001 		break;

  1002 	case 2:

  1003 		aMember.iInvertMask=EFalse;

  1004 		aMember.iDrawMode=CGraphicsContext::EDrawModeXOR;

  1005 		aMember.iOffset=TPoint(1,2);

  1006 		aMember.iInterval=TTimeIntervalMicroSeconds32(2);

  1007 		break;

  1008 	case 3:

  1009 		aMember.iInvertMask=ETrue;

  1010 		aMember.iDrawMode=CGraphicsContext::EDrawModeOR;

  1011 		aMember.iOffset=TPoint(3,4);

  1012 		aMember.iInterval=TTimeIntervalMicroSeconds32(3);

  1013 		break;

  1014 	default:

  1015 		iTest->SetUpMember(aMember);

  1016 		}

  1017 	}

  1018 

  1019 /**

  1020 @SYMTestCaseID		GRAPHICS-WSERV-0132

  1021 

  1022 @SYMDEF             DEF081259

  1023 

  1024 @SYMTestCaseDesc    Sprite animation test

  1025 

  1026 @SYMTestPriority    High

  1027 

  1028 @SYMTestStatus      Implemented

  1029 

  1030 @SYMTestActions     Creates a sprite with three sprite members and a sprite animation

  1031 					passing the sprite to it. The test updates sprite members'

  1032 					properties in various ways verifying that the properties are changing

  1033 					on the server-side as well.

  1034 

  1035 @SYMTestExpectedResults Expects that operations above do not fail and that client-side

  1036 					changes to the sprite affect server-side properly.

  1037 */

  1038 #define HALF_SEC 500000

  1039 void CTAnimDll::SpriteAnimL()

  1040 	{

  1041 	// create a sprite, add 3 members to it

  1042 	RWsSprite sprite(TheClient->iWs);

  1043 	iRedrawWin->BaseWin()->SetVisible(ETrue);

  1044 	sprite.Construct(*iRedrawWin->CtBaseWin()->BaseWin(),TPoint(),0);

  1045 	CleanupClosePushL(sprite);

  1046 	CFbsBitmap* bitmap1=new(ELeave) CFbsBitmap();

  1047 	CleanupStack::PushL(bitmap1);

  1048 	CFbsBitmap* bitmap2=new(ELeave) CFbsBitmap();

  1049 	CleanupStack::PushL(bitmap2);

  1050 	CFbsBitmap* bitmap3=new(ELeave) CFbsBitmap();

  1051 	CleanupStack::PushL(bitmap3);

  1052 	User::LeaveIfError(bitmap1->Create(TSize(10,12),EGray4));

  1053 	User::LeaveIfError(bitmap2->Create(TSize(15,17),EGray4));

  1054 	User::LeaveIfError(bitmap3->Create(TSize(20,22),EGray4));

  1055 	TSpriteMember member1;

  1056 	TSpriteMember member2;

  1057 	TSpriteMember member3;

  1058 	SetUpMember(member1,1);

  1059 	member1.iBitmap=bitmap1;

  1060 	member1.iMaskBitmap=bitmap1;

  1061 	SetUpMember(member2,2);

  1062 	member2.iBitmap=bitmap2;

  1063 	member2.iMaskBitmap=bitmap2;

  1064 	SetUpMember(member3,3);

  1065 	member3.iBitmap=bitmap3;

  1066 	member3.iMaskBitmap=bitmap3;

  1067 	sprite.AppendMember(member1);

  1068 	sprite.AppendMember(member2);

  1069 	sprite.AppendMember(member3);

  1070 

  1071 	// create a sprite animation for the sprite

  1072 	RTestAnim spriteAnim(iAnimDll);

  1073 	TPtrC8 des(NULL,0);

  1074 	TPoint pos(1,2);

  1075 	User::LeaveIfError(spriteAnim.Construct(sprite,EAnimTypeSprite,des));

  1076 	CleanupClosePushL(spriteAnim);

  1077 

  1078 	// call EADllCheckMember-command to verify that sprite animation's members

  1079 	// have the same properties as the sprite instance

  1080 	TPckgBuf<TSpriteMemberInfo> spriteInfo;

  1081 	spriteInfo()=TSpriteMemberInfo(TPoint(),0,member1);

  1082 	TBool retBool = spriteAnim.CommandReply(EADllCheckMember,spriteInfo);

  1083 	TEST(retBool);

  1084 	if (!retBool)

  1085 		INFO_PRINTF3(_L("spriteAnim.CommandReply(EADllCheckMember,spriteInfo) return value - Expected: %d , Actual: %d"), ETrue, retBool);

  1086 

  1087 	sprite.SetPosition(pos);

  1088 	spriteInfo()=TSpriteMemberInfo(pos,1,member2);

  1089 	retBool = spriteAnim.CommandReply(EADllCheckMember,spriteInfo);

  1090 	TEST(retBool);

  1091 	if (!retBool)

  1092 		INFO_PRINTF3(_L("spriteAnim.CommandReply(EADllCheckMember,spriteInfo) return value - Expected: %d , Actual: %d"), ETrue, retBool);

  1093 

  1094 	pos.SetXY(3,4);

  1095 	sprite.SetPosition(pos);

  1096 	spriteInfo()=TSpriteMemberInfo(pos,2,member3);

  1097 	retBool = spriteAnim.CommandReply(EADllCheckMember,spriteInfo);

  1098 	TEST(retBool);

  1099 	if (!retBool)

  1100 		INFO_PRINTF3(_L("spriteAnim.CommandReply(EADllCheckMember,spriteInfo) return value - Expected: %d , Actual: %d"), ETrue, retBool);

  1101 

  1102 	// call commands to change sprite members' bitmaps and update members

  1103 	spriteAnim.Command(EADllDraw1);

  1104 	spriteAnim.Command(EADllDraw2);

  1105 	spriteAnim.Command(EADllDraw3);

  1106 	TheClient->iWs.Flush();

  1107 	User::After(HALF_SEC);

  1108 

  1109 	// call commands to change sprite's position

  1110 	TPckgBuf<TPoint> position;

  1111 	position().SetXY(60,50);

  1112 	spriteAnim.Command(EADllSetPos,position);

  1113 	TheClient->iWs.Flush();

  1114 	User::After(HALF_SEC);

  1115 

  1116 	// change 1st member's bitmap size and interval, update it and call command to check

  1117 	// that the new properties are applied

  1118 	User::LeaveIfError(bitmap1->Resize(TSize(30,32)));

  1119 	member1.iMaskBitmap=NULL;

  1120 	member1.iInterval=TTimeIntervalMicroSeconds32(25);

  1121 	User::LeaveIfError(sprite.UpdateMember(0,member1));

  1122 	spriteInfo()=TSpriteMemberInfo(TPoint(),0,member1);

  1123 	retBool = spriteAnim.CommandReply(EADllCheckMember,spriteInfo);

  1124 	TEST(retBool);

  1125 	if (!retBool)

  1126 		INFO_PRINTF3(_L("spriteAnim.CommandReply(EADllCheckMember,spriteInfo) return value - Expected: %d , Actual: %d"), ETrue, retBool);

  1127 

  1128 	User::After(HALF_SEC);

  1129 

  1130 	// change 1st member's bitmap size and calls command that invokes

  1131 	// MAnimSpriteFunctions::SizeChangedL(). Check that new property is applied

  1132 	spriteAnim.CommandReply(EADllDeactivate);

  1133 	User::LeaveIfError(bitmap1->Resize(TSize(35,37)));

  1134 	spriteAnim.Command(EADllSizeChanged);