1 /*

     2 * Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  test function implement of CTestPlatAlfVisual

    15 *

    16 */

    17 

    18 

    19 // [INCLUDE FILES]

    20 #include <alf/alfborderbrush.h>

    21 #include <alf/alfbitmapprovider.h>

    22 #include <avkon.mbg>

    23 

    24 #include "testplatalfvisual.h"

    25 

    26 

    27 // CONSTANTS

    28 const TInt KImageWidth = 60;

    29 const TInt KImageHeight = 670;

    30 const TInt KGeneralTime = 1000000;

    31 

    32 

    33 // FORWARD DECLARATION

    34 // class CTestBitmapProvider for testing CAlfBorderBrush

    35 class CTestBitmapProvider : public CBase, public MAlfBitmapProvider

    36     {

    37 public:

    38     /**

    39      * Constructor

    40      */

    41     CTestBitmapProvider() : iImageNumber( 0 ) {}

    42     

    43     /**

    44      * From MAlfBitmapProvider

    45      * 

    46      * Provide a bitmap and mask from the given UID.

    47      */

    48     void ProvideBitmapL( TInt /*aId*/, CFbsBitmap*& aBitmap, CFbsBitmap*& aBitmapMask )

    49         {

    50         TBool done = EFalse;

    51         

    52         while ( !done )

    53             {

    54             AknIconUtils::CreateIconL( aBitmap, aBitmapMask, 

    55                 AknIconUtils::AvkonIconFileName(), 

    56                 EMbmAvkonQgn_indi_find_glass + iImageNumber,

    57                 EMbmAvkonQgn_indi_find_glass_mask + iImageNumber );

    58 

    59             AknIconUtils::SetSize( aBitmap, TSize( KImageWidth, KImageHeight ) );

    60             

    61             // Alf does not support all displaymodes, so continue until we find supported image

    62             if ( !aBitmap || aBitmap->DisplayMode() < EColor64K

    63                  || !aBitmapMask || aBitmapMask->DisplayMode() != EGray256 )

    64                 {

    65                 delete aBitmap;

    66                 delete aBitmapMask;

    67                 aBitmap = NULL;

    68                 aBitmapMask = NULL;

    69                 iImageNumber += 2;

    70                 }

    71             else

    72                 {

    73                 done = ETrue;

    74                 }

    75             }

    76         }

    77     

    78 private:

    79     /**

    80      * The number of image

    81      */

    82     TInt iImageNumber;

    83     };

    84 

    85 

    86 // ============================ MEMBER FUNCTIONS ===============================

    87 

    88 // -----------------------------------------------------------------------------

    89 // CTestPlatAlfVisual::TestBorderBrushNewL

    90 // -----------------------------------------------------------------------------

    91 TInt CTestPlatAlfVisual::TestBorderBrushNewL( CStifItemParser& /*aItem*/ )

    92     {

    93 

    94     // Print to UI

    95     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

    96     _LIT( KTestBorderBrushNewL, "TestBorderBrushNewL" );

    97     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBorderBrushNewL );

    98     // Print to log file

    99     iLog->Log( KTestBorderBrushNewL );

   100     

   101     TAlfXYMetric thickness;

   102     TAlfXYMetric edgeOffset;

   103     CAlfBorderBrush* brush = CAlfBorderBrush::NewL( *iAlfEnv, thickness, edgeOffset );

   104     CleanupStack::PushL( brush );

   105     STIF_ASSERT_NOT_NULL( brush );

   106     CleanupStack::PopAndDestroy( brush );

   107     

   108     return KErrNone;

   109     }

   110 // -----------------------------------------------------------------------------

   111 // CTestPlatAlfVisual::TestBorderBrushNewLCL

   112 // -----------------------------------------------------------------------------

   113 TInt CTestPlatAlfVisual::TestBorderBrushNewLCL( CStifItemParser& /*aItem*/ )

   114     {

   115 

   116     // Print to UI

   117     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   118     _LIT( KTestBorderBrushNewLCL, "TestBorderBrushNewLCL" );

   119     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBorderBrushNewLCL );

   120     // Print to log file

   121     iLog->Log( KTestBorderBrushNewLCL );

   122     

   123     TAlfXYMetric thickness;

   124     TAlfXYMetric edgeOffset;

   125     CAlfBorderBrush* brush = CAlfBorderBrush::NewLC( *iAlfEnv, thickness, edgeOffset );

   126     STIF_ASSERT_NOT_NULL( brush );

   127     CleanupStack::PopAndDestroy( brush );

   128     

   129     return KErrNone;

   130     }

   131 // -----------------------------------------------------------------------------

   132 // CTestPlatAlfVisual::TestBorderBrushOffsetNewL

   133 // -----------------------------------------------------------------------------

   134 TInt CTestPlatAlfVisual::TestBorderBrushOffsetNewL( CStifItemParser& /*aItem*/ )

   135     {

   136 

   137     // Print to UI

   138     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   139     _LIT( KTestBorderBrushOffsetNewL, "TestBorderBrushOffsetNewL" );

   140     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBorderBrushOffsetNewL );

   141     // Print to log file

   142     iLog->Log( KTestBorderBrushOffsetNewL );

   143     

   144     CAlfBorderBrush* brush = CAlfBorderBrush::NewL( *iAlfEnv, 0,0,0,0 ); 

   145     CleanupStack::PushL( brush );

   146     STIF_ASSERT_NOT_NULL( brush );

   147     CleanupStack::PopAndDestroy( brush );

   148     

   149     brush = CAlfBorderBrush::NewL( *iAlfEnv, -1, 11231230, -04234234234, 0 );

   150     CleanupStack::PushL( brush );

   151     STIF_ASSERT_NOT_NULL( brush );

   152     CleanupStack::PopAndDestroy( brush );

   153     

   154     return KErrNone;

   155     }

   156 // -----------------------------------------------------------------------------

   157 // CTestPlatAlfVisual::TestBorderBrushOffsetNewLCL

   158 // -----------------------------------------------------------------------------

   159 TInt CTestPlatAlfVisual::TestBorderBrushOffsetNewLCL( CStifItemParser& /*aItem*/ )

   160     {

   161 

   162     // Print to UI

   163     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   164     _LIT( KTestBorderBrushOffsetNewLCL, "TestBorderBrushOffsetNewLCL" );

   165     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBorderBrushOffsetNewLCL );

   166     // Print to log file

   167     iLog->Log( KTestBorderBrushOffsetNewLCL );

   168 

   169     CAlfBorderBrush* brush = CAlfBorderBrush::NewLC( *iAlfEnv, 0, 0, 0, 0 );

   170     STIF_ASSERT_NOT_NULL( brush );

   171     CleanupStack::PopAndDestroy( brush );

   172     

   173     return KErrNone;

   174     }

   175 // -----------------------------------------------------------------------------

   176 // CTestPlatAlfVisual::TestBorderBrushSetImageL

   177 // -----------------------------------------------------------------------------

   178 TInt CTestPlatAlfVisual::TestBorderBrushSetImageL( CStifItemParser& /*aItem*/ )

   179     {

   180 

   181     // Print to UI

   182     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   183     _LIT( KTestBorderBrushSetImageL, "TestBorderBrushSetImageL" );

   184     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBorderBrushSetImageL );

   185     // Print to log file

   186     iLog->Log( KTestBorderBrushSetImageL );

   187 

   188     CTestBitmapProvider* bmpProvider = new ( ELeave ) CTestBitmapProvider;

   189     CleanupStack::PushL( bmpProvider );

   190     CAlfBorderBrush* brush = CAlfBorderBrush::NewL( *iAlfEnv, 0, 0, 0, 0 );

   191     CleanupStack::PushL( brush );

   192     CAlfTexture& texture = iAlfEnv->TextureManager().CreateTextureL( 2,

   193                                          bmpProvider,

   194                                          EAlfTextureFlagGenerateShadow );

   195                                          

   196     brush->SetImage( TAlfImage( texture ) );

   197     CleanupStack::PopAndDestroy( brush );

   198     CleanupStack::PopAndDestroy( bmpProvider );

   199 

   200     return KErrNone;

   201     }

   202 // -----------------------------------------------------------------------------

   203 // CTestPlatAlfVisual::TestBorderBrushImageL

   204 // -----------------------------------------------------------------------------

   205 TInt CTestPlatAlfVisual::TestBorderBrushImageL( CStifItemParser& /*aItem*/ )

   206     {

   207 

   208     // Print to UI

   209     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   210     _LIT( KTestBorderBrushImageL, "TestBorderBrushImageL" );

   211     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBorderBrushImageL );

   212     // Print to log file

   213     iLog->Log( KTestBorderBrushImageL );

   214 

   215     CAlfBorderBrush* brush = CAlfBorderBrush::NewL( *iAlfEnv, 0, 0, 0, 0 );

   216     CleanupStack::PushL( brush );

   217     brush->Image();

   218     CleanupStack::PopAndDestroy( brush );

   219 

   220     return KErrNone;

   221     }

   222 // -----------------------------------------------------------------------------

   223 // CTestPlatAlfVisual::TestBorderBrushSetColorL

   224 // -----------------------------------------------------------------------------

   225 TInt CTestPlatAlfVisual::TestBorderBrushSetColorL( CStifItemParser& /*aItem*/ )

   226     {

   227 

   228     // Print to UI

   229     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   230     _LIT( KTestBorderBrushSetColorL, "TestBorderBrushSetColorL" );

   231     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBorderBrushSetColorL );

   232     // Print to log file

   233     iLog->Log( KTestBorderBrushSetColorL );

   234 

   235     CAlfBorderBrush* brush = CAlfBorderBrush::NewL( *iAlfEnv, 0, 0, 0, 0 );

   236     CleanupStack::PushL( brush );

   237     brush->SetColor( KRgbDarkGray );

   238     CleanupStack::PopAndDestroy( brush );

   239 

   240     return KErrNone;

   241     }

   242 // -----------------------------------------------------------------------------

   243 // CTestPlatAlfVisual::TestBorderBrushThicknessL

   244 // -----------------------------------------------------------------------------

   245 TInt CTestPlatAlfVisual::TestBorderBrushThicknessL( CStifItemParser& /*aItem*/ )

   246     {

   247 

   248     // Print to UI

   249     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   250     _LIT( KTestBorderBrushThicknessL, "TestBorderBrushThicknessL" );

   251     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBorderBrushThicknessL );

   252     // Print to log file

   253     iLog->Log( KTestBorderBrushThicknessL );

   254 

   255     CAlfBorderBrush* brush = CAlfBorderBrush::NewL( *iAlfEnv, 0, 0, 0, 0 );

   256     CleanupStack::PushL( brush );

   257     const TAlfTimedPoint& valueGet = brush->Thickness();

   258     STIF_ASSERT_EQUALS( 0.f, valueGet.iX.ValueNow() );

   259     STIF_ASSERT_EQUALS( 0.f, valueGet.iX.Target() );

   260     STIF_ASSERT_EQUALS( 0, valueGet.iX.TimeToTargetinMilliSeconds() );

   261     CleanupStack::PopAndDestroy( brush );

   262 

   263     return KErrNone;

   264     }

   265 // -----------------------------------------------------------------------------

   266 // CTestPlatAlfVisual::TestBorderBrushSetThicknessL

   267 // -----------------------------------------------------------------------------

   268 TInt CTestPlatAlfVisual::TestBorderBrushSetThicknessL( CStifItemParser& /*aItem*/ )

   269     {

   270 

   271     // Print to UI

   272     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   273     _LIT( KTestBorderBrushSetThicknessL, "TestBorderBrushSetThicknessL" );

   274     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBorderBrushSetThicknessL );

   275     // Print to log file

   276     iLog->Log( KTestBorderBrushSetThicknessL );

   277 

   278     CAlfBorderBrush* brush = CAlfBorderBrush::NewL( *iAlfEnv, 0, 0, 0, 0 );

   279     CleanupStack::PushL( brush );

   280     TAlfTimedPoint valueSet;

   281     valueSet.iY.SetValueNow( 0 );

   282     valueSet.iY.SetTarget( 1, KGeneralTime );

   283     brush->SetThickness( valueSet );

   284     

   285     const TAlfTimedPoint& valueGet = brush->Thickness();

   286     STIF_ASSERT_EQUALS( 0.f, valueGet.iY.ValueNow() );

   287     STIF_ASSERT_EQUALS( 1.f, valueGet.iY.Target() );

   288     STIF_ASSERT_NOT_EQUALS( 0, valueGet.iY.TimeToTargetinMilliSeconds() );

   289     CleanupStack::PopAndDestroy( brush );

   290 

   291     return KErrNone;

   292     }

   293 // -----------------------------------------------------------------------------

   294 // CTestPlatAlfVisual::TestBorderBrushSetThicknessMetricL

   295 // -----------------------------------------------------------------------------

   296 TInt CTestPlatAlfVisual::TestBorderBrushSetThicknessMetricL( CStifItemParser& /*aItem*/ )

   297     {

   298 

   299     // Print to UI

   300     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   301     _LIT( KTestBorderBrushSetThicknessMetricL, "TestBorderBrushSetThicknessMetricL" );

   302     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBorderBrushSetThicknessMetricL );

   303     // Print to log file

   304     iLog->Log( KTestBorderBrushSetThicknessMetricL );

   305 

   306     CAlfBorderBrush* brush = CAlfBorderBrush::NewL( *iAlfEnv, 0, 0, 0, 0 );

   307     CleanupStack::PushL( brush );

   308     TAlfMetric valueSet( 2.f );

   309     brush->SetThickness( valueSet );

   310     

   311     const TAlfTimedPoint& valueGet = brush->Thickness();

   312     STIF_ASSERT_EQUALS( 2.f, valueGet.iY.ValueNow() );

   313     STIF_ASSERT_EQUALS( 2.f, valueGet.iY.Target() );

   314     STIF_ASSERT_EQUALS( 0, valueGet.iY.TimeToTargetinMilliSeconds() );

   315     CleanupStack::PopAndDestroy( brush );

   316 

   317     return KErrNone;

   318     }

   319 // -----------------------------------------------------------------------------

   320 // CTestPlatAlfVisual::TestBorderBrushEdgeOffsetL

   321 // -----------------------------------------------------------------------------

   322 TInt CTestPlatAlfVisual::TestBorderBrushEdgeOffsetL( CStifItemParser& /*aItem*/ )

   323     {

   324 

   325     // Print to UI

   326     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   327     _LIT( KTestBorderBrushEdgeOffsetL, "TestBorderBrushEdgeOffsetL" );

   328     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBorderBrushEdgeOffsetL );

   329     // Print to log file

   330     iLog->Log( KTestBorderBrushEdgeOffsetL );

   331 

   332     CAlfBorderBrush* brush = CAlfBorderBrush::NewL( *iAlfEnv, 0, 0, 0, 0 );

   333     CleanupStack::PushL( brush );

   334     const TAlfTimedPoint& valueGet = brush->EdgeOffset();

   335     STIF_ASSERT_EQUALS( 0.f, valueGet.iX.ValueNow() );

   336     STIF_ASSERT_EQUALS( 0.f, valueGet.iX.Target() );

   337     STIF_ASSERT_EQUALS( 0, valueGet.iX.TimeToTargetinMilliSeconds() );

   338     CleanupStack::PopAndDestroy( brush );

   339 

   340     return KErrNone;

   341     }

   342 // -----------------------------------------------------------------------------

   343 // CTestPlatAlfVisual::TestBorderBrushSetEdgeOffsetL

   344 // -----------------------------------------------------------------------------

   345 TInt CTestPlatAlfVisual::TestBorderBrushSetEdgeOffsetL( CStifItemParser& /*aItem*/ )

   346     {

   347 

   348     // Print to UI

   349     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   350     _LIT( KTestBorderBrushSetEdgeOffsetL, "TestBorderBrushSetEdgeOffsetL" );

   351     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBorderBrushSetEdgeOffsetL );

   352     // Print to log file

   353     iLog->Log( KTestBorderBrushSetEdgeOffsetL );

   354 

   355     CAlfBorderBrush* brush = CAlfBorderBrush::NewL( *iAlfEnv, 0, 0, 0, 0 );

   356     CleanupStack::PushL( brush );

   357     TAlfTimedPoint valueSet;

   358     valueSet.iX.SetValueNow( 0 );

   359     valueSet.iX.SetTarget( 1, KGeneralTime );

   360     brush->SetEdgeOffset( valueSet );

   361     

   362     const TAlfTimedPoint& valueGet = brush->EdgeOffset();

   363     STIF_ASSERT_EQUALS( 0.f, valueGet.iX.ValueNow() );

   364     STIF_ASSERT_EQUALS( 1.f, valueGet.iX.Target() );

   365     STIF_ASSERT_NOT_EQUALS( 0, valueGet.iX.TimeToTargetinMilliSeconds() );

   366     CleanupStack::PopAndDestroy( brush );

   367 

   368     return KErrNone;

   369     }

   370 // -----------------------------------------------------------------------------

   371 // CTestPlatAlfVisual::TestBorderBrushSetEdgeOffsetMetricL

   372 // -----------------------------------------------------------------------------

   373 TInt CTestPlatAlfVisual::TestBorderBrushSetEdgeOffsetMetricL( CStifItemParser& /*aItem*/ )

   374     {

   375 

   376     // Print to UI

   377     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   378     _LIT( KTestBorderBrushSetEdgeOffsetMetricL, "TestBorderBrushSetEdgeOffsetMetricL" );

   379     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBorderBrushSetEdgeOffsetMetricL );

   380     // Print to log file

   381     iLog->Log( KTestBorderBrushSetEdgeOffsetMetricL );

   382 

   383     CAlfBorderBrush* brush = CAlfBorderBrush::NewL( *iAlfEnv, 0, 0, 0, 0 );

   384     CleanupStack::PushL( brush );

   385     TAlfMetric valueSet( 2.f );

   386     brush->SetEdgeOffset( valueSet );

   387     

   388     const TAlfTimedPoint& valueGet = brush->EdgeOffset();

   389     STIF_ASSERT_EQUALS( 2.f, valueGet.iX.ValueNow() );

   390     STIF_ASSERT_EQUALS( 2.f, valueGet.iX.Target() );

   391     STIF_ASSERT_EQUALS( 0, valueGet.iX.TimeToTargetinMilliSeconds() );

   392     CleanupStack::PopAndDestroy( brush );

   393 

   394     return KErrNone;

   395     }

   396 // -----------------------------------------------------------------------------

   397 // CTestPlatAlfVisual::TestBorderBrushImageOffsetL

   398 // -----------------------------------------------------------------------------

   399 TInt CTestPlatAlfVisual::TestBorderBrushImageOffsetL( CStifItemParser& /*aItem*/ )

   400     {

   401 

   402     // Print to UI

   403     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   404     _LIT( KTestBorderBrushImageOffsetL, "TestBorderBrushImageOffsetL" );

   405     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBorderBrushImageOffsetL );

   406     // Print to log file

   407     iLog->Log( KTestBorderBrushImageOffsetL );

   408 

   409     CAlfBorderBrush* brush = CAlfBorderBrush::NewL( *iAlfEnv, 0, 0, 0, 0 );

   410     CleanupStack::PushL( brush );

   411     const TAlfTimedPoint& valueGet = brush->ImageOffset();

   412     STIF_ASSERT_EQUALS( 0.f, valueGet.iX.ValueNow() );

   413     STIF_ASSERT_EQUALS( 0.f, valueGet.iX.Target() );

   414     STIF_ASSERT_EQUALS( 0, valueGet.iX.TimeToTargetinMilliSeconds() );

   415     CleanupStack::PopAndDestroy( brush );

   416 

   417     return KErrNone;

   418     }

   419 // -----------------------------------------------------------------------------

   420 // CTestPlatAlfVisual::TestBorderBrushSetImageOffsetL

   421 // -----------------------------------------------------------------------------

   422 TInt CTestPlatAlfVisual::TestBorderBrushSetImageOffsetL( CStifItemParser& /*aItem*/ )

   423     {

   424 

   425     // Print to UI

   426     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   427     _LIT( KTestBorderBrushSetImageOffsetL, "TestBorderBrushSetImageOffsetL" );

   428     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBorderBrushSetImageOffsetL );

   429     // Print to log file

   430     iLog->Log( KTestBorderBrushSetImageOffsetL );

   431 

   432     CAlfBorderBrush* brush = CAlfBorderBrush::NewL( *iAlfEnv, 0, 0, 0, 0 );

   433     CleanupStack::PushL( brush );

   434     TAlfTimedPoint valueSet;

   435     valueSet.iY.SetValueNow( 0 );

   436     valueSet.iY.SetTarget( 1, KGeneralTime );

   437     brush->SetImageOffset( valueSet );

   438     

   439     const TAlfTimedPoint& valueGet = brush->ImageOffset();

   440     STIF_ASSERT_EQUALS( 0.f, valueGet.iY.ValueNow() );

   441     STIF_ASSERT_EQUALS( 1.f, valueGet.iY.Target() );

   442     STIF_ASSERT_NOT_EQUALS( 0, valueGet.iY.TimeToTargetinMilliSeconds() );

   443     CleanupStack::PopAndDestroy( brush );

   444 

   445     return KErrNone;

   446     }

   447 // -----------------------------------------------------------------------------

   448 // CTestPlatAlfVisual::TestBorderBrushSetImageOffsetMetricL

   449 // -----------------------------------------------------------------------------

   450 TInt CTestPlatAlfVisual::TestBorderBrushSetImageOffsetMetricL( CStifItemParser& /*aItem*/ )

   451     {

   452 

   453     // Print to UI

   454     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   455     _LIT( KTestBorderBrushSetImageOffsetMetricL, "TestBorderBrushSetImageOffsetMetricL" );

   456     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBorderBrushSetImageOffsetMetricL );

   457     // Print to log file

   458     iLog->Log( KTestBorderBrushSetImageOffsetMetricL );

   459 

   460     CAlfBorderBrush* brush = CAlfBorderBrush::NewL( *iAlfEnv, 0, 0, 0, 0 );

   461     CleanupStack::PushL( brush );

   462     TAlfMetric valueSet( 2.f );

   463     brush->SetImageOffset( valueSet );

   464     

   465     const TAlfTimedPoint& valueGet = brush->ImageOffset();

   466     STIF_ASSERT_EQUALS( 2.f, valueGet.iY.ValueNow() );

   467     STIF_ASSERT_EQUALS( 2.f, valueGet.iY.Target() );

   468     STIF_ASSERT_EQUALS( 0, valueGet.iY.TimeToTargetinMilliSeconds() );

   469     CleanupStack::PopAndDestroy( brush );

   470 

   471     return KErrNone;

   472     }

   473 

   474 

   475 //  [End of File]