/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  test functions for alfvisual.h

*

*/

// [INCLUDE FILES]

#include <alf/alfvisual.h>

#include <alf/alfvisualfactory.h>

#include <touchlogicalfeedback.h>

#include <alf/alfpropertyowner.h>

#include "testplatalfvisual.h"

// CONSTANTS

const TUint KRefFlag = 0;

const TInt KNum10 = 10;

const TInt KNum20 = 20;

const TInt KNum30 = 30;

const TInt KNum40 = 40;

const TInt KNum50 = 50;

const TInt KNum65 = 65;

const TInt KNum88 = 88;

const TInt KNum100 = 100;

const TInt KNum120 = 120;

const TInt KNum200 = 200;

const TInt KNum300 = 300;

const TReal32 KReal1 = 20.4;

const TReal32 KReal2 = 30.3;

const TReal32 KReal3 = 40.3;

const TReal32 KReal4 = 50.4;

const TReal32 KReal5 = 0.6;

const TReal32 KReal6 = 0.3;

const TReal32 KReal7 = 12.3;

// FORWARD DECLARATION

// class CTestAlfVisual for testing CAlfVisual

class CTestAlfVisual : public CAlfVisual

    {

public:

    // From CAlfVisual

    void PropertyOwnerExtension( const TUid& aExtensionUid, TAny** aExtensionParams )

        {

        CAlfVisual::PropertyOwnerExtension( aExtensionUid, aExtensionParams );

        }

    };

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

// -----------------------------------------------------------------------------

// CTestPlatAlfVisual::TestCAlfVCAlfVisualL

// -----------------------------------------------------------------------------

//

TInt CTestPlatAlfVisual::TestCAlfVCAlfVisualL( CStifItemParser& /*aItem*/ )

    {

    // Print to UI

    _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

    _LIT( KTestCAlfVCAlfVisualL, "TestCAlfVCAlfVisualL" );

    TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVCAlfVisualL );

    // Print to log file

    iLog->Log( KTestCAlfVCAlfVisualL );

    CAlfVisual* alfVisual = new ( ELeave ) CAlfVisual();

    CleanupStack::PushL( alfVisual );

    STIF_ASSERT_NOT_NULL( alfVisual );

    CleanupStack::PopAndDestroy( alfVisual );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CTestPlatAlfVisual::TestCAlfVConstructL

// -----------------------------------------------------------------------------

//

TInt CTestPlatAlfVisual::TestCAlfVConstructL( CStifItemParser& /*aItem*/ )

    {

    // Print to UI

    _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

    _LIT( KTestCAlfVConstructL, "TestCAlfVConstructL" );

    TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVConstructL );

    // Print to log file

    iLog->Log( KTestCAlfVConstructL );

    CAlfVisual* alfVisual = new ( ELeave ) CAlfVisual();

    CleanupStack::PushL( alfVisual );

    STIF_ASSERT_NOT_NULL( alfVisual );

    alfVisual->ConstructL( *iAlfCtl );

    CleanupStack::PopAndDestroy( alfVisual );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CTestPlatAlfVisual::TestCAlfVRemoveAndDestroyAllDL

// -----------------------------------------------------------------------------

//

TInt CTestPlatAlfVisual::TestCAlfVRemoveAndDestroyAllDL( CStifItemParser& /*aItem*/ )

    {

    // Print to UI

    _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

    _LIT( KTestCAlfVRemoveAndDestroyAllDL, "TestCAlfVRemoveAndDestroyAllDL" );

    TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVRemoveAndDestroyAllDL );

    // Print to log file

    iLog->Log( KTestCAlfVRemoveAndDestroyAllDL );

    CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

            EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

    STIF_ASSERT_NOT_NULL( alfVisual );

    alfVisual->RemoveAndDestroyAllD();

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CTestPlatAlfVisual::TestCAlfVIdentifierL

// -----------------------------------------------------------------------------

//

TInt CTestPlatAlfVisual::TestCAlfVIdentifierL( CStifItemParser& /*aItem*/ )

    {

    // Print to UI

    _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

    _LIT( KTestCAlfVIdentifierL, "TestCAlfVIdentifierL" );

    TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVIdentifierL );

    // Print to log file

    iLog->Log( KTestCAlfVIdentifierL );

    CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

                EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

    CleanupStack::PushL( alfVisual );

    STIF_ASSERT_NOT_NULL( alfVisual );

    STIF_ASSERT_NOT_EQUALS( 0, alfVisual->Identifier() );

    CleanupStack::PopAndDestroy( alfVisual );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CTestPlatAlfVisual::TestCAlfVSetFlagL

// -----------------------------------------------------------------------------

//

TInt CTestPlatAlfVisual::TestCAlfVSetFlagL( CStifItemParser& /*aItem*/ )

    {

    // Print to UI

    _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

    _LIT( KTestCAlfVSetFlagL, "TestCAlfVSetFlagL" );

    TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVSetFlagL );

    // Print to log file

    iLog->Log( KTestCAlfVSetFlagL );

    CAlfVisual* alfVisual = iAlfCtl->AppendVisualL( EAlfVisualTypeVisual );

    CleanupStack::PushL( alfVisual );

    STIF_ASSERT_NOT_NULL( alfVisual );

    // Create layout parent for testing purposes

    CAlfLayout* parentLayout = iAlfCtl->AppendLayoutL( EAlfLayoutTypeDeck );

    CleanupStack::PushL( parentLayout );

    User::LeaveIfError( parentLayout->Append( alfVisual ) ); 

    parentLayout->SetFlag( EAlfVisualFlagManualLayout );

    parentLayout->SetPos( TAlfRealPoint( KNum40, KNum50 ) );

    parentLayout->SetSize( TAlfRealSize( KNum100, KNum120 ) );

    parentLayout->UpdateChildrenLayout();

    TAlfTimedPoint size = alfVisual->Size(); 

    STIF_ASSERT_EQUALS( KNum100+0.f, size.iX.Target() );

    STIF_ASSERT_EQUALS( KNum120+0.f, size.iY.Target() );

    TAlfTimedPoint pos = alfVisual->Pos(); 

    STIF_ASSERT_EQUALS( 0.f, pos.iX.Target() );

    STIF_ASSERT_EQUALS( 0.f, pos.iY.Target() );

    // 1# EAlfVisualFlagManualSize

    alfVisual->SetSize( TAlfRealSize( KNum10, KNum20 ) );   // 1. resize without the flag

    parentLayout->UpdateChildrenLayout();           // 2. relayout siblings

    size = alfVisual->Size();                       // 3. check that the visual still has the original size

    STIF_ASSERT_EQUALS( KNum100+0.f, size.iX.Target() );

    STIF_ASSERT_EQUALS( KNum120+0.f, size.iY.Target() );

    alfVisual->SetFlag( EAlfVisualFlagManualSize ); // 4. set the manual size flag

    alfVisual->SetSize( TAlfRealSize( KNum10, KNum20 ) );   // 5. resize again

    parentLayout->UpdateChildrenLayout();           // 6. relayout siblings

    size = alfVisual->Size();                       // 7. check the the new size is still valid

    STIF_ASSERT_EQUALS( KNum10+0.f, size.iX.Target() );

    STIF_ASSERT_EQUALS( KNum20+0.f, size.iY.Target() );

    // 2# EAlfVisualFlagManualPosition

    alfVisual->SetPos( TAlfRealPoint( KNum10, KNum20 ) );   // 1. replace without the flag

    parentLayout->UpdateChildrenLayout();           // 2. relayout siblings

    pos = alfVisual->Pos();                         // 3. check that the visual still has the original position

    STIF_ASSERT_EQUALS( 0.f, pos.iX.Target() );

    STIF_ASSERT_EQUALS( 0.f, pos.iY.Target() );

    alfVisual->SetFlag( EAlfVisualFlagManualPosition );// 4. set the manual position flag

    alfVisual->SetPos( TAlfRealPoint( KNum10, KNum20 ) );      // 5. replace again

    parentLayout->UpdateChildrenLayout();              // 6. relayout siblings

    pos = alfVisual->Pos();                            // 7. check the the new posotion is still valid

    STIF_ASSERT_EQUALS( KNum10+0.f, pos.iX.Target() );

    STIF_ASSERT_EQUALS( KNum20+0.f, pos.iY.Target() );

    // 3# AlfVisualFlagClipping

    alfVisual->SetFlag( AlfVisualFlagClipping );

    // 4# EAlfVisualFlagLayoutUpdateNotification

    parentLayout->UpdateChildrenLayout();

    // 5# EAlfVisualFlag3DProjection

    alfVisual->SetFlag( EAlfVisualFlag3DProjection );

    // 6# EAlfVisualFlagNoDepthOcclusion

    alfVisual->SetFlag( EAlfVisualFlagNoDepthOcclusion );

    // 7# EAlfVisualFlagLocalHorizon

    alfVisual->SetFlag( EAlfVisualFlagLocalHorizon );

    // 8# EAlfVisualFlagClipping

    alfVisual->SetFlag( EAlfVisualFlagClipping );

    // 8# EAlfVisualFlagHOriginCenter

    alfVisual->SetFlag( EAlfVisualFlagHOriginCenter );

    // 8# EAlfVisualFlagHOriginRight

    alfVisual->SetFlag( EAlfVisualFlagHOriginRight );

    // 8# EAlfVisualFlagVOriginCenter

    alfVisual->SetFlag( EAlfVisualFlagVOriginCenter );

    // 8# EAlfVisualFlagVOriginBottom

    alfVisual->SetFlag( EAlfVisualFlagVOriginBottom );

    CleanupStack::Pop( parentLayout );

    CleanupStack::Pop( alfVisual );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CTestPlatAlfVisual::TestCAlfVSetFlagsL

// -----------------------------------------------------------------------------

//

TInt CTestPlatAlfVisual::TestCAlfVSetFlagsL( CStifItemParser& /*aItem*/ )

    {

    // Print to UI

    _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

    _LIT( KTestCAlfVSetFlagsL, "TestCAlfVSetFlagsL" );

    TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVSetFlagsL );

    // Print to log file

    iLog->Log( KTestCAlfVSetFlagsL );

    CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

                    EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

    CleanupStack::PushL( alfVisual );

    STIF_ASSERT_NOT_NULL( alfVisual );

    TUint flags = EAlfVisualFlagVOriginCenter +

                  EAlfVisualFlagNoDepthOcclusion +

                  EAlfVisualFlagClipping;

    alfVisual->SetFlags( flags );

    TUint retFlags = alfVisual->Flags();

    STIF_ASSERT_NOT_EQUALS( KRefFlag, ( retFlags & EAlfVisualFlagVOriginCenter ) );

    STIF_ASSERT_NOT_EQUALS( KRefFlag, ( retFlags & EAlfVisualFlagNoDepthOcclusion ) );

    STIF_ASSERT_NOT_EQUALS( KRefFlag, ( retFlags & EAlfVisualFlagClipping ) );

    CleanupStack::PopAndDestroy( alfVisual );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CTestPlatAlfVisual::TestCAlfVClearFlagL

// -----------------------------------------------------------------------------

//

TInt CTestPlatAlfVisual::TestCAlfVClearFlagL( CStifItemParser& /*aItem*/ )

    {

    // Print to UI

    _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

    _LIT( KTestCAlfVClearFlagL, "TestCAlfVClearFlagL" );

    TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVClearFlagL );

    // Print to log file

    iLog->Log( KTestCAlfVClearFlagL );

    CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

                    EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

    CleanupStack::PushL( alfVisual );

    STIF_ASSERT_NOT_NULL( alfVisual );

    TUint flags = EAlfVisualFlagVOriginCenter +

                  EAlfVisualFlagNoDepthOcclusion +

                  EAlfVisualFlagClipping;

    alfVisual->SetFlags( flags );

    alfVisual->ClearFlag( EAlfVisualFlagNoDepthOcclusion );

    alfVisual->ClearFlag( EAlfVisualFlagClipping );

    TUint retFlags = alfVisual->Flags();

    STIF_ASSERT_NOT_EQUALS( KRefFlag, ( retFlags & EAlfVisualFlagVOriginCenter ) );

    STIF_ASSERT_EQUALS( KRefFlag, ( retFlags & EAlfVisualFlagNoDepthOcclusion ) );

    STIF_ASSERT_EQUALS( KRefFlag, ( retFlags & EAlfVisualFlagClipping ) );

    CleanupStack::PopAndDestroy( alfVisual );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CTestPlatAlfVisual::TestCAlfVClearFlagsL

// -----------------------------------------------------------------------------

//

TInt CTestPlatAlfVisual::TestCAlfVClearFlagsL( CStifItemParser& /*aItem*/ )

    {

    // Print to UI

    _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

    _LIT( KTestCAlfVClearFlagsL, "TestCAlfVClearFlagsL" );

    TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVClearFlagsL );

    // Print to log file

    iLog->Log( KTestCAlfVClearFlagsL );

    CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

                    EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

    CleanupStack::PushL( alfVisual );

    STIF_ASSERT_NOT_NULL( alfVisual );

    TUint flags = EAlfVisualFlagVOriginCenter +

                  EAlfVisualFlagNoDepthOcclusion +

                  EAlfVisualFlagClipping;

    alfVisual->SetFlags( flags );

    alfVisual->ClearFlags( EAlfVisualFlagNoDepthOcclusion + EAlfVisualFlagClipping );

    TUint retFlags = alfVisual->Flags();

    STIF_ASSERT_NOT_EQUALS( KRefFlag, ( retFlags & EAlfVisualFlagVOriginCenter ) );

    STIF_ASSERT_EQUALS( KRefFlag, ( retFlags & EAlfVisualFlagNoDepthOcclusion ) );

    STIF_ASSERT_EQUALS( KRefFlag, ( retFlags & EAlfVisualFlagClipping ) );

    CleanupStack::PopAndDestroy( alfVisual );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CTestPlatAlfVisual::TestCAlfVFlagsL

// -----------------------------------------------------------------------------

//

TInt CTestPlatAlfVisual::TestCAlfVFlagsL( CStifItemParser& /*aItem*/ )

    {

    // Print to UI

    _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

    _LIT( KTestCAlfVFlagsL, "TestCAlfVFlagsL" );

    TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVFlagsL );

    // Print to log file

    iLog->Log( KTestCAlfVFlagsL );

    CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

                    EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

    CleanupStack::PushL( alfVisual );

    STIF_ASSERT_NOT_NULL( alfVisual );

    alfVisual->SetFlag( EAlfVisualFlagVOriginCenter );

    TUint retFlags = alfVisual->Flags();

    STIF_ASSERT_NOT_EQUALS( KRefFlag , ( retFlags & EAlfVisualFlagVOriginCenter ) );

    alfVisual->SetFlag( EAlfVisualFlagNoDepthOcclusion );

    retFlags = alfVisual->Flags();

    STIF_ASSERT_NOT_EQUALS( KRefFlag , ( retFlags & EAlfVisualFlagNoDepthOcclusion ) );

    alfVisual->SetFlag( EAlfVisualFlagClipping );

    retFlags = alfVisual->Flags();

    STIF_ASSERT_NOT_EQUALS( KRefFlag , ( retFlags & EAlfVisualFlagClipping ) );

    alfVisual->ClearFlag( EAlfVisualFlagNoDepthOcclusion );

    retFlags = alfVisual->Flags();

    STIF_ASSERT_EQUALS( KRefFlag , ( retFlags & EAlfVisualFlagNoDepthOcclusion ) );

    alfVisual->ClearFlag( EAlfVisualFlagVOriginCenter );

    retFlags = alfVisual->Flags();

    STIF_ASSERT_EQUALS( KRefFlag , ( retFlags & EAlfVisualFlagVOriginCenter ) );

    alfVisual->ClearFlag( EAlfVisualFlagClipping );

    retFlags = alfVisual->Flags();

    STIF_ASSERT_EQUALS( KRefFlag , ( retFlags & EAlfVisualFlagClipping ) );

    CleanupStack::PopAndDestroy( alfVisual );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CTestPlatAlfVisual::TestCAlfVLayoutL

// -----------------------------------------------------------------------------

//

TInt CTestPlatAlfVisual::TestCAlfVLayoutL( CStifItemParser& /*aItem*/ )

    {

    // Print to UI

    _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

    _LIT( KTestCAlfVLayoutL, "TestCAlfVLayoutL" );

    TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVLayoutL );

    // Print to log file

    iLog->Log( KTestCAlfVLayoutL );

    CAlfVisual* alfVisual = iAlfCtl->AppendVisualL( EAlfVisualTypeVisual );

    CleanupStack::PushL( alfVisual );

    STIF_ASSERT_NOT_NULL( alfVisual );

    STIF_ASSERT_NULL( alfVisual->Layout() );

    CAlfLayout* parentLayout = iAlfCtl->AppendLayoutL( EAlfLayoutTypeDeck );

    CleanupStack::PushL( parentLayout );

    STIF_ASSERT_NOT_NULL( parentLayout );

    User::LeaveIfError( parentLayout->Append( alfVisual ) ); // calls SetLayout()

    STIF_ASSERT_EQUALS( parentLayout, alfVisual->Layout() );

    CleanupStack::Pop( parentLayout );

    CleanupStack::Pop( alfVisual );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CTestPlatAlfVisual::TestCAlfVPosL

// -----------------------------------------------------------------------------

//

TInt CTestPlatAlfVisual::TestCAlfVPosL( CStifItemParser& /*aItem*/ )

    {

    // Print to UI

    _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

    _LIT( KTestCAlfVPosL, "TestCAlfVPosL" );

    TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVPosL );

    // Print to log file

    iLog->Log( KTestCAlfVPosL );

    CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

                    EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

    CleanupStack::PushL( alfVisual );

    STIF_ASSERT_NOT_NULL( alfVisual );

    TAlfRealPoint pos( KNum20, KNum30 );

    alfVisual->SetPos( pos );

    TAlfTimedPoint result = alfVisual->Pos();

    STIF_ASSERT_EQUALS( KNum20+0.f, result.iX.ValueNow() );

    STIF_ASSERT_EQUALS( KNum30+0.f, result.iY.ValueNow() );

    STIF_ASSERT_EQUALS( KNum20+0.f, result.iX.Target() );

    STIF_ASSERT_EQUALS( KNum30+0.f, result.iY.Target() );

    CleanupStack::PopAndDestroy( alfVisual );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CTestPlatAlfVisual::TestCAlfVSetPosL

// -----------------------------------------------------------------------------

//

TInt CTestPlatAlfVisual::TestCAlfVSetPosL( CStifItemParser& /*aItem*/ )

    {

    // Print to UI

    _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

    _LIT( KTestCAlfVSetPosL, "TestCAlfVSetPosL" );

    TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVSetPosL );

    // Print to log file

    iLog->Log( KTestCAlfVSetPosL );

    CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

                    EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

    CleanupStack::PushL( alfVisual );

    STIF_ASSERT_NOT_NULL( alfVisual );

    TAlfRealPoint pos( KNum20, KNum30 );

    alfVisual->SetPos( pos );

    TAlfTimedPoint result = alfVisual->Pos();

    STIF_ASSERT_EQUALS( KNum20+0.f, result.iX.ValueNow() );

    STIF_ASSERT_EQUALS( KNum30+0.f, result.iY.ValueNow() );

    STIF_ASSERT_EQUALS( KNum20+0.f, result.iX.Target() );

    STIF_ASSERT_EQUALS( KNum30+0.f, result.iY.Target() );

    pos = TAlfRealPoint( KNum40, KNum50 );

    alfVisual->SetPos( pos, KNum10);

    result = alfVisual->Pos();

    STIF_ASSERT_NOT_EQUALS( KNum40+0.f, result.iX.ValueNow() );

    STIF_ASSERT_NOT_EQUALS( KNum50+0.f, result.iY.ValueNow() );

    STIF_ASSERT_EQUALS( KNum40+0.f, result.iX.Target() );

    STIF_ASSERT_EQUALS( KNum50+0.f, result.iY.Target() );

    CleanupStack::PopAndDestroy( alfVisual );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CTestPlatAlfVisual::TestCAlfVSizeL

// -----------------------------------------------------------------------------

//

TInt CTestPlatAlfVisual::TestCAlfVSizeL( CStifItemParser& /*aItem*/ )

    {

    // Print to UI

    _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

    _LIT( KTestCAlfVSizeL, "TestCAlfVSizeL" );

    TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVSizeL );

    // Print to log file

    iLog->Log( KTestCAlfVSizeL );

    CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

                    EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

    CleanupStack::PushL( alfVisual );

    STIF_ASSERT_NOT_NULL( alfVisual );

    TAlfRealSize size( KNum20, KNum30 );

    alfVisual->SetSize( size );

    TAlfTimedPoint result = alfVisual->Size();

    STIF_ASSERT_EQUALS( KNum20+0.f, result.iX.ValueNow() );

    STIF_ASSERT_EQUALS( KNum30+0.f, result.iY.ValueNow() );

    STIF_ASSERT_EQUALS( KNum20+0.f, result.iX.Target() );

    STIF_ASSERT_EQUALS( KNum30+0.f, result.iY.Target() );

    CleanupStack::PopAndDestroy( alfVisual );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CTestPlatAlfVisual::TestCAlfVSetSizeL

// -----------------------------------------------------------------------------