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/alfbrusharray.h>

    21 #include <alf/alflayout.h>

    22 #include <alf/alfborderbrush.h>

    23 

    24 #include "testplatalfvisual.h"

    25 

    26 

    27 // CONSTANTS

    28 const TInt KBrushParam = 3;

    29 const TInt KBrushCount = 4;

    30 

    31 

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

    33 

    34 // -----------------------------------------------------------------------------

    35 // CTestPlatAlfVisual::TestBrushArrayResetL

    36 // -----------------------------------------------------------------------------

    37 TInt CTestPlatAlfVisual::TestBrushArrayResetL( CStifItemParser& /*aItem*/ )

    38     {

    39     // Print to UI

    40     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

    41     _LIT( KTestBrushArrayResetL, "TestBrushArrayResetL" );

    42     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBrushArrayResetL );

    43     // Print to log file

    44     iLog->Log( KTestBrushArrayResetL );

    45     

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

    47     CAlfBrush* brushOwn = CAlfBorderBrush::NewLC( *iAlfEnv, 1, 1, 1, 1 );

    48 

    49     CAlfVisual* visual = CAlfLayout::AddNewL( *iAlfCtl );

    50     visual->EnableBrushesL();

    51     CAlfBrushArray* brushArray = visual->Brushes();

    52     STIF_ASSERT_EQUALS( 0, brushArray->Count() );

    53     

    54     brushArray->AppendL( brush, EAlfDoesNotHaveOwnership );

    55     brushArray->AppendL( brushOwn, EAlfHasOwnership );

    56     

    57     STIF_ASSERT_EQUALS( 2, brushArray->Count() );

    58     

    59     brushArray->Reset();

    60     STIF_ASSERT_EQUALS( 0, brushArray->Count() );

    61     

    62     CleanupStack::Pop( brushOwn );

    63     CleanupStack::PopAndDestroy( brush );

    64     

    65     return KErrNone;

    66     }

    67 

    68 // -----------------------------------------------------------------------------

    69 // CTestPlatAlfVisual::TestBrushArrayAppendL

    70 // -----------------------------------------------------------------------------

    71 TInt CTestPlatAlfVisual::TestBrushArrayAppendL( CStifItemParser& /*aItem*/ )

    72     {

    73     // Print to UI

    74     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

    75     _LIT( KTestBrushArrayAppendL, "TestBrushArrayAppendL" );

    76     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBrushArrayAppendL );

    77     // Print to log file

    78     iLog->Log( KTestBrushArrayAppendL );

    79     

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

    81     CAlfBrush* brushOwn = CAlfBorderBrush::NewLC( *iAlfEnv, 1, 1, 1, 1 );

    82     

    83     CAlfVisual* visual = CAlfLayout::AddNewL( *iAlfCtl );

    84     visual->EnableBrushesL();

    85     CAlfBrushArray* brushArray = visual->Brushes();

    86     

    87     STIF_ASSERT_EQUALS( 0, brushArray->Count() );

    88     brushArray->AppendL( brushOwn, EAlfHasOwnership );

    89     brushArray->AppendL( brush, EAlfDoesNotHaveOwnership );

    90     STIF_ASSERT_EQUALS( 2, brushArray->Count() );

    91     

    92     CleanupStack::Pop( brushOwn );

    93     CleanupStack::PopAndDestroy( brush );

    94     

    95     return KErrNone;

    96     }

    97 

    98 // -----------------------------------------------------------------------------

    99 // CTestPlatAlfVisual::TestBrushArrayInsertL

   100 // -----------------------------------------------------------------------------

   101 TInt CTestPlatAlfVisual::TestBrushArrayInsertL( CStifItemParser& /*aItem*/ )

   102     {

   103     // Print to UI

   104     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   105     _LIT( KTestBrushArrayInsertL, "TestBrushArrayInsertL" );

   106     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBrushArrayInsertL );

   107     // Print to log file

   108     iLog->Log( KTestBrushArrayInsertL );

   109     

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

   111     CAlfBrush* brushOwn = CAlfBorderBrush::NewLC( *iAlfEnv, 1, 1, 1, 1 );

   112     

   113     CAlfVisual* visual = CAlfLayout::AddNewL( *iAlfCtl );

   114     visual->EnableBrushesL();

   115     CAlfBrushArray* brushArray = visual->Brushes();

   116     

   117     STIF_ASSERT_EQUALS( 0, brushArray->Count() );

   118     brushArray->AppendL( brush, EAlfDoesNotHaveOwnership );

   119     brushArray->InsertL( 0, brushOwn, EAlfHasOwnership );

   120     STIF_ASSERT_EQUALS( 2, brushArray->Count() );

   121     

   122     CleanupStack::Pop( brushOwn );

   123     CleanupStack::PopAndDestroy( brush );

   124     

   125     return KErrNone;

   126     }

   127 

   128 // -----------------------------------------------------------------------------

   129 // CTestPlatAlfVisual::TestBrushArrayRemoveL

   130 // -----------------------------------------------------------------------------

   131 TInt CTestPlatAlfVisual::TestBrushArrayRemoveL( CStifItemParser& /*aItem*/ )

   132     {

   133     // Print to UI

   134     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   135     _LIT( KTestBrushArrayRemoveL, "TestBrushArrayRemoveL" );

   136     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBrushArrayRemoveL );

   137     // Print to log file

   138     iLog->Log( KTestBrushArrayRemoveL );

   139     

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

   141     CAlfBrush* brushOwn = CAlfBorderBrush::NewLC( *iAlfEnv, 1, 1, 1, 1 );

   142     

   143     CAlfVisual* visual = CAlfLayout::AddNewL( *iAlfCtl );

   144     visual->EnableBrushesL();

   145     CAlfBrushArray* brushArray = visual->Brushes();

   146     

   147     STIF_ASSERT_EQUALS( 0, brushArray->Count() );

   148     brushArray->AppendL( brushOwn, EAlfHasOwnership );

   149     brushArray->AppendL( brush, EAlfDoesNotHaveOwnership );

   150     STIF_ASSERT_EQUALS( 2, brushArray->Count() );

   151     CleanupStack::Pop( brushOwn );

   152     brushArray->Remove( 0 );

   153     STIF_ASSERT_EQUALS( 1, brushArray->Count() );

   154     brushArray->Remove( 0 );

   155     STIF_ASSERT_EQUALS( 0, brushArray->Count() );

   156     CleanupStack::PopAndDestroy( brush );

   157     

   158     return KErrNone;

   159     }

   160 

   161 // -----------------------------------------------------------------------------

   162 // CTestPlatAlfVisual::TestBrushArrayCountL

   163 // -----------------------------------------------------------------------------

   164 TInt CTestPlatAlfVisual::TestBrushArrayCountL( CStifItemParser& /*aItem*/ )

   165     {

   166     // Print to UI

   167     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   168     _LIT( KTestBrushArrayCountL, "TestBrushArrayCountL" );

   169     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBrushArrayCountL );

   170     // Print to log file

   171     iLog->Log( KTestBrushArrayCountL );

   172     

   173     CAlfBrush* brush1 = CAlfBorderBrush::NewLC( *iAlfEnv, 0, 0, 0, 0 );

   174     CAlfBrush* brush2 = CAlfBorderBrush::NewLC( *iAlfEnv, 1, 1, 1, 1 );

   175     CAlfBrush* brushOwn1 = CAlfBorderBrush::NewLC( *iAlfEnv, 2, 2, 2, 2 );

   176     CAlfBrush* brushOwn2 = CAlfBorderBrush::NewLC( *iAlfEnv,

   177             KBrushParam, KBrushParam, KBrushParam, KBrushParam );

   178     

   179     CAlfVisual* visual = CAlfLayout::AddNewL( *iAlfCtl );

   180     visual->EnableBrushesL();

   181     CAlfBrushArray* brushArray = visual->Brushes();

   182     

   183     TInt count = brushArray->Count();

   184     STIF_ASSERT_EQUALS( 0, count );

   185     

   186     brushArray->AppendL( brushOwn1, EAlfHasOwnership );

   187     brushArray->AppendL( brush1, EAlfDoesNotHaveOwnership );

   188     brushArray->AppendL( brushOwn2, EAlfHasOwnership );

   189     brushArray->AppendL( brush2, EAlfDoesNotHaveOwnership );

   190     

   191     count = brushArray->Count();

   192     STIF_ASSERT_EQUALS( KBrushCount, count );

   193     

   194     CleanupStack::Pop( brushOwn2 );

   195     CleanupStack::Pop( brushOwn1 );

   196     CleanupStack::PopAndDestroy( brush2 );

   197     CleanupStack::PopAndDestroy( brush1 );

   198     

   199     return KErrNone;

   200     }

   201 

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

   203 // CTestPlatAlfVisual::TestBrushArrayOperatorL

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

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

   206     {

   207     // Print to UI

   208     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   209     _LIT( KTestBrushArrayOperatorL, "TestBrushArrayOperatorL" );

   210     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBrushArrayOperatorL );

   211     // Print to log file

   212     iLog->Log( KTestBrushArrayOperatorL );

   213     

   214     CAlfBrush* brushOwn = CAlfBorderBrush::NewLC( *iAlfEnv, 1, 1, 1, 1 );

   215     

   216     CAlfVisual* visual = CAlfLayout::AddNewL( *iAlfCtl );

   217     visual->EnableBrushesL();

   218     CAlfBrushArray* brushArray = visual->Brushes();

   219     

   220     brushArray->AppendL( brushOwn, EAlfHasOwnership );

   221     

   222     if ( brushArray->Count() > 0 )

   223         {

   224         CAlfBrush* brush = &(*brushArray)[0];

   225         STIF_ASSERT_EQUALS( brush, brushOwn );

   226         }

   227     

   228     CleanupStack::Pop( brushOwn );

   229     

   230     return KErrNone;

   231     }

   232 

   233 // -----------------------------------------------------------------------------

   234 // CTestPlatAlfVisual::TestBrushArrayAtL

   235 // -----------------------------------------------------------------------------

   236 TInt CTestPlatAlfVisual::TestBrushArrayAtL( CStifItemParser& /*aItem*/ )

   237     {

   238     // Print to UI

   239     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   240     _LIT( KTestBrushArrayAtL, "TestBrushArrayAtL" );

   241     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestBrushArrayAtL );

   242     // Print to log file

   243     iLog->Log( KTestBrushArrayAtL );

   244     

   245     CAlfBrush* brushOwn = CAlfBorderBrush::NewLC( *iAlfEnv, 1, 1, 1, 1 );

   246     

   247     CAlfVisual* visual = CAlfLayout::AddNewL( *iAlfCtl );

   248     visual->EnableBrushesL();

   249     CAlfBrushArray* brushArray = visual->Brushes();

   250     

   251     brushArray->AppendL( brushOwn, EAlfHasOwnership );

   252     

   253     if ( brushArray->Count() > 0 )

   254         {

   255         CAlfBrush* brush = &brushArray->At( 0 );

   256         STIF_ASSERT_EQUALS( brush, brushOwn );

   257         }

   258     

   259     CleanupStack::Pop( brushOwn );

   260     

   261     return KErrNone;

   262     }

   263 

   264 

   265 //  [End of File]