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 aknqueryvalueduration.h

    15 *

    16 */

    17 

    18 //INCLUDE

    19 #include <aknqueryvalueduration.h>

    20 #include <testsdkqueries.rsg>

    21 

    22 #include "testsdkqueries.h"

    23 

    24 const TInt KZero = 0;

    25 const TInt KOne = 1;

    26 const TInt KTwo = 2;

    27 const TInt KThree = 3;

    28 const TInt KDurationOne = 200;

    29 const TInt KDurationTwo = 780;

    30 const TInt KBufSize = 32;

    31 const TInt KTimeIntervalSeconds = 10000;

    32 

    33 // -----------------------------------------------------------------------------

    34 // CTestSDKQueries::TestQVDurationNewL

    35 // -----------------------------------------------------------------------------

    36 //

    37 TInt CTestSDKQueries::TestQVDurationNewL( CStifItemParser& /*aItem*/ )

    38     {

    39     CAknQueryValueDuration* duration = CAknQueryValueDuration::NewL();

    40     CleanupStack::PushL( duration );

    41     

    42     STIF_ASSERT_NOT_NULL( duration );

    43     

    44     CleanupStack::PopAndDestroy( duration );

    45     return KErrNone;

    46     }

    47 

    48 // -----------------------------------------------------------------------------

    49 // CTestSDKQueries::TestQVDurationNewLC

    50 // -----------------------------------------------------------------------------

    51 //

    52 TInt CTestSDKQueries::TestQVDurationNewLCL( CStifItemParser& /*aItem*/ )

    53     {

    54     CAknQueryValueDuration* duration = CAknQueryValueDuration::NewLC();

    55     

    56     STIF_ASSERT_NOT_NULL( duration );

    57     

    58     CleanupStack::PopAndDestroy( duration );

    59     return KErrNone;

    60     }

    61 

    62 // -----------------------------------------------------------------------------

    63 // CTestSDKQueries::TestQVDurationDestructorL

    64 // -----------------------------------------------------------------------------

    65 //

    66 TInt CTestSDKQueries::TestQVDurationDestructorL( CStifItemParser& /*aItem*/ )

    67     {

    68     CAknQueryValueDuration* duration = CAknQueryValueDuration::NewLC();

    69     CleanupStack::PopAndDestroy( duration );

    70     

    71     return KErrNone;

    72     }

    73 

    74 // -----------------------------------------------------------------------------

    75 // CTestSDKQueries::TestQVDurationSetArrayL

    76 // -----------------------------------------------------------------------------

    77 //

    78 TInt CTestSDKQueries::TestQVDurationSetArrayL( CStifItemParser& /*aItem*/ )

    79     {

    80     CAknQueryValueDuration* duration = CAknQueryValueDuration::NewLC();

    81     

    82     CAknQueryValueDurationArray* mArray = 

    83         CAknQueryValueDurationArray::NewL( R_TESTQUERY_TIME_FORMAT );

    84     CleanupStack::PushL( mArray );

    85     

    86     duration->SetArrayL( mArray );

    87     

    88     CleanupStack::Pop( mArray );

    89     CleanupStack::PopAndDestroy( duration );

    90     return KErrNone;

    91     }

    92 

    93 // -----------------------------------------------------------------------------

    94 // CTestSDKQueries::TestQVDurationSetQueryCaptionL

    95 // -----------------------------------------------------------------------------

    96 //

    97 TInt CTestSDKQueries::TestQVDurationSetQueryCaptionL( CStifItemParser& /*aItem*/ )

    98     {

    99     CAknQueryValueDuration* duration = CAknQueryValueDuration::NewLC();

   100     

   101     duration->SetQueryCaption( R_TESTQUERY_CAPTION );

   102     

   103     CleanupStack::PopAndDestroy( duration );

   104     return KErrNone;

   105     }

   106 

   107 // -----------------------------------------------------------------------------

   108 // CTestSDKQueries::TestQVDurationValueL

   109 // -----------------------------------------------------------------------------

   110 //

   111 TInt CTestSDKQueries::TestQVDurationValueL( CStifItemParser& /*aItem*/ )

   112     {

   113     CAknQueryValueDuration* duration = CAknQueryValueDuration::NewLC();

   114     

   115     TTimeIntervalSeconds value = duration->Value();

   116     

   117     TTimeIntervalSeconds compareValue( KZero );

   118     STIF_ASSERT_EQUALS( compareValue, value );

   119     

   120     CleanupStack::PopAndDestroy( duration );

   121     return KErrNone;

   122     }

   123 

   124 // -----------------------------------------------------------------------------

   125 // CTestSDKQueries::TestQVDurationMdcArrayL

   126 // -----------------------------------------------------------------------------

   127 //

   128 TInt CTestSDKQueries::TestQVDurationMdcArrayL( CStifItemParser& /*aItem*/ )

   129     {

   130     CAknQueryValueDuration* duration = CAknQueryValueDuration::NewLC();

   131     

   132     const MDesCArray* returnArray = duration->MdcArray();

   133     STIF_ASSERT_NULL( returnArray );

   134     

   135     CAknQueryValueDurationArray* mArray = 

   136         CAknQueryValueDurationArray::NewL( R_TESTQUERY_TIME_FORMAT );

   137     CleanupStack::PushL( mArray );

   138     

   139     duration->SetArrayL( mArray );

   140     

   141     const MDesCArray* returnArrayTwo = duration->MdcArray();

   142     

   143     STIF_ASSERT_EQUALS( mArray, ( CAknQueryValueDurationArray* )returnArrayTwo );

   144     

   145     CleanupStack::Pop( mArray );

   146     CleanupStack::PopAndDestroy( duration );

   147     return KErrNone;

   148     }

   149 

   150 // -----------------------------------------------------------------------------

   151 // CTestSDKQueries::TestQVDurationCurrentValueTextLCL

   152 // -----------------------------------------------------------------------------

   153 //

   154 TInt CTestSDKQueries::TestQVDurationCurrentValueTextLCL( CStifItemParser& /*aItem*/ )

   155     {

   156     CAknQueryValueDuration* duration = CAknQueryValueDuration::NewLC();

   157     

   158     CArrayFix<TTimeIntervalSeconds>* durationArray = new( ELeave ) 

   159         CArrayFixFlat<TTimeIntervalSeconds>( 2 );

   160     CleanupStack::PushL( durationArray );

   161     TTimeIntervalSeconds dura1( KDurationOne );

   162     TTimeIntervalSeconds dura2( KDurationTwo );

   163     

   164     durationArray->AppendL( dura1 );

   165     durationArray->AppendL( dura2 );

   166     

   167     CAknQueryValueDurationArray* mArray = CAknQueryValueDurationArray::NewL(

   168         R_TESTQUERY_TIME_FORMAT );

   169     CleanupStack::PushL( mArray );

   170     

   171     mArray->SetArray( *durationArray );

   172     

   173     duration->SetArrayL( mArray );

   174     

   175     HBufC* text = duration->CurrentValueTextLC();

   176     STIF_ASSERT_NOT_NULL( text );

   177     

   178     CleanupStack::Pop( KThree );

   179     CleanupStack::PopAndDestroy( duration );

   180     return KErrNone;

   181     }

   182 

   183 // -----------------------------------------------------------------------------

   184 // CTestSDKQueries::TestQVDurationCurrentValueIndexL

   185 // -----------------------------------------------------------------------------

   186 //

   187 TInt CTestSDKQueries::TestQVDurationCurrentValueIndexL( CStifItemParser& /*aItem*/ )

   188     {

   189     CAknQueryValueDuration* duration = CAknQueryValueDuration::NewLC();

   190     

   191     TInt mIndex = duration->CurrentValueIndex();

   192     STIF_ASSERT_EQUALS( KZero, mIndex );

   193     

   194     CArrayFix<TTimeIntervalSeconds>* durationArray = new( ELeave ) 

   195         CArrayFixFlat<TTimeIntervalSeconds>( 2 );

   196     CleanupStack::PushL( durationArray );

   197     TTimeIntervalSeconds dura1( KDurationOne );

   198     TTimeIntervalSeconds dura2( KDurationTwo );

   199     

   200     durationArray->AppendL( dura1 );

   201     durationArray->AppendL( dura2 );

   202     

   203     CAknQueryValueDurationArray* mArray = CAknQueryValueDurationArray::NewL(

   204         R_TESTQUERY_TIME_FORMAT );

   205     CleanupStack::PushL( mArray );

   206     

   207     mArray->SetArray( *durationArray );

   208     

   209     duration->SetArrayL( mArray );

   210     

   211     duration->SetCurrentValueIndex( KOne );

   212     

   213     mIndex = duration->CurrentValueIndex();

   214     STIF_ASSERT_EQUALS( KOne, mIndex );

   215     

   216     CleanupStack::Pop( KTwo );

   217     CleanupStack::PopAndDestroy( duration );

   218     return KErrNone;

   219     }

   220 

   221 // -----------------------------------------------------------------------------

   222 // CTestSDKQueries::TestQVDurationSetCurrentValueIndexL

   223 // -----------------------------------------------------------------------------

   224 //

   225 TInt CTestSDKQueries::TestQVDurationSetCurrentValueIndexL( CStifItemParser& aItem )

   226     {

   227     TInt err = TestQVDurationCurrentValueIndexL( aItem );

   228     return err;

   229     }

   230 

   231 // -----------------------------------------------------------------------------

   232 // CTestSDKQueries::TestQVDurationCreateEditorL

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

   234 //

   235 TInt CTestSDKQueries::TestQVDurationCreateEditorL( CStifItemParser& /*aItem*/ )

   236     {

   237     CAknQueryValueDuration* duration = CAknQueryValueDuration::NewLC();

   238     

   239     CArrayFix<TTimeIntervalSeconds>* durationArray = new( ELeave ) 

   240         CArrayFixFlat<TTimeIntervalSeconds>( 2 );

   241     CleanupStack::PushL( durationArray );

   242     TTimeIntervalSeconds dura1( KDurationOne );

   243     TTimeIntervalSeconds dura2( KDurationTwo );

   244     

   245     durationArray->AppendL( dura1 );

   246     durationArray->AppendL( dura2 );

   247     

   248     CAknQueryValueDurationArray* mArray = CAknQueryValueDurationArray::NewL(

   249         R_TESTQUERY_TIME_FORMAT );

   250     CleanupStack::PushL( mArray );

   251     

   252     mArray->SetArray( *durationArray );

   253     

   254     duration->SetArrayL( mArray );

   255     

   256     duration->SetCurrentValueIndex( KZero );

   257     

   258     TBool flag = duration->CreateEditorL();

   259     STIF_ASSERT_TRUE( flag );

   260     

   261     CleanupStack::Pop( KTwo );

   262     CleanupStack::PopAndDestroy( duration );

   263     return KErrNone;

   264     }

   265 

   266 // -----------------------------------------------------------------------------

   267 // CTestSDKQueries::TestQVDArrayNewL

   268 // -----------------------------------------------------------------------------

   269 //

   270 TInt CTestSDKQueries::TestQVDArrayNewL( CStifItemParser& /*aItem*/ )

   271     {

   272     CAknQueryValueDurationArray* durationArray = 

   273         CAknQueryValueDurationArray::NewL( R_TESTQUERY_TIME_FORMAT );

   274     CleanupStack::PushL( durationArray );

   275     

   276     STIF_ASSERT_NOT_NULL( durationArray );

   277     

   278     CleanupStack::PopAndDestroy( durationArray );

   279     return KErrNone;

   280     }

   281 

   282 // -----------------------------------------------------------------------------

   283 // CTestSDKQueries::TestQVDArrayNewLCL

   284 // -----------------------------------------------------------------------------

   285 //

   286 TInt CTestSDKQueries::TestQVDArrayNewLCL( CStifItemParser& /*aItem*/ )

   287     {

   288     CAknQueryValueDurationArray* durationArray = 

   289         CAknQueryValueDurationArray::NewLC( R_TESTQUERY_TIME_FORMAT );

   290     

   291     STIF_ASSERT_NOT_NULL( durationArray );

   292     

   293     CleanupStack::PopAndDestroy( durationArray );

   294     return KErrNone;

   295     }

   296 

   297 // -----------------------------------------------------------------------------

   298 // CTestSDKQueries::TestQVDArrayDestructorL

   299 // -----------------------------------------------------------------------------

   300 //

   301 TInt CTestSDKQueries::TestQVDArrayDestructorL( CStifItemParser& /*aItem*/ )

   302     {

   303     CAknQueryValueDurationArray* durationArray = 

   304         CAknQueryValueDurationArray::NewLC( R_TESTQUERY_TIME_FORMAT );

   305     CleanupStack::PopAndDestroy( durationArray );

   306     

   307     return KErrNone;

   308     }

   309 

   310 // -----------------------------------------------------------------------------

   311 // CTestSDKQueries::TestQVDArraySetArrayL

   312 // -----------------------------------------------------------------------------

   313 //

   314 TInt CTestSDKQueries::TestQVDArraySetArrayL( CStifItemParser& /*aItem*/ )

   315     {

   316     CAknQueryValueDurationArray* durationArray = 

   317         CAknQueryValueDurationArray::NewLC( R_TESTQUERY_TIME_FORMAT );

   318     

   319     CArrayFix<TTimeIntervalSeconds>* returnArray = durationArray->Array();

   320     STIF_ASSERT_NULL( returnArray );

   321     

   322     CArrayFix<TTimeIntervalSeconds>* mArray = new( ELeave ) 

   323         CArrayFixFlat<TTimeIntervalSeconds>( 2 );

   324     CleanupStack::PushL( mArray );

   325     

   326     TTimeIntervalSeconds dura1( KDurationOne );

   327     TTimeIntervalSeconds dura2( KDurationTwo );

   328     

   329     mArray->AppendL( dura1 );

   330     mArray->AppendL( dura2 );

   331     

   332     durationArray->SetArray( *mArray );

   333     

   334     returnArray = durationArray->Array();

   335     STIF_ASSERT_EQUALS( mArray, returnArray );

   336     

   337     CleanupStack::Pop( mArray );

   338     CleanupStack::PopAndDestroy( durationArray );

   339     return KErrNone;

   340     }

   341 

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

   343 // CTestSDKQueries::TestQVDArrayArrayL

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

   345 //

   346 TInt CTestSDKQueries::TestQVDArrayArrayL( CStifItemParser& aItem )

   347     {

   348     TInt err = TestQVDArraySetArrayL( aItem );

   349     return err;

   350     }

   351 

   352 // -----------------------------------------------------------------------------

   353 // CTestSDKQueries::TestQVDArrayFormatStringL

   354 // -----------------------------------------------------------------------------

   355 //

   356 TInt CTestSDKQueries::TestQVDArrayFormatStringL( CStifItemParser& /*aItem*/ )

   357     {

   358     CAknQueryValueDurationArray* durationArray = 

   359         CAknQueryValueDurationArray::NewLC( R_TESTQUERY_TIME_FORMAT );

   360     

   361     CArrayFix<TTimeIntervalSeconds>* mArray = new( ELeave ) 

   362         CArrayFixFlat<TTimeIntervalSeconds>( 2 );

   363     CleanupStack::PushL( mArray );

   364     

   365     TTimeIntervalSeconds dura1( KDurationOne );

   366     TTimeIntervalSeconds dura2( KDurationTwo );

   367     

   368     mArray->AppendL( dura1 );

   369     mArray->AppendL( dura2 );

   370     

   371     durationArray->SetArray( *mArray );

   372     

   373     const HBufC* text = durationArray->FormatString();

   374     STIF_ASSERT_NOT_NULL( text );

   375     

   376     CleanupStack::Pop( mArray );

   377     CleanupStack::PopAndDestroy( durationArray );

   378     return KErrNone;

   379     }

   380 

   381 // -----------------------------------------------------------------------------

   382 // CTestSDKQueries::TestQVDArrayFormattedStringSizeOneL

   383 // -----------------------------------------------------------------------------

   384 //

   385 TInt CTestSDKQueries::TestQVDArrayFormattedStringSizeOneL( CStifItemParser& /*aItem*/ )

   386     {

   387     CAknQueryValueDurationArray* durationArray = 

   388         CAknQueryValueDurationArray::NewLC( R_TESTQUERY_TIME_FORMAT );

   389     

   390     CArrayFix<TTimeIntervalSeconds>* mArray = new( ELeave ) 

   391         CArrayFixFlat<TTimeIntervalSeconds>( 2 );

   392     CleanupStack::PushL( mArray );

   393     

   394     TTimeIntervalSeconds dura1( KDurationOne );

   395     TTimeIntervalSeconds dura2( KDurationTwo );

   396     

   397     mArray->AppendL( dura1 );

   398     mArray->AppendL( dura2 );

   399     

   400     durationArray->SetArray( *mArray );

   401     

   402     const TInt size = durationArray->FormattedStringSize();

   403     STIF_ASSERT_NOT_EQUALS( KZero, size );

   404     

   405     CleanupStack::Pop( mArray );

   406     CleanupStack::PopAndDestroy( durationArray );

   407     return KErrNone;

   408     }

   409 

   410 // -----------------------------------------------------------------------------

   411 // CTestSDKQueries::TestQVDArrayFormattedStringSizeTwoL

   412 // -----------------------------------------------------------------------------

   413 //

   414 TInt CTestSDKQueries::TestQVDArrayFormattedStringSizeTwoL( CStifItemParser& /*aItem*/ )

   415     {

   416     CAknQueryValueDurationArray* durationArray = 

   417         CAknQueryValueDurationArray::NewLC( R_TESTQUERY_TIME_FORMAT );

   418     

   419     CArrayFix<TTimeIntervalSeconds>* mArray = new( ELeave ) 

   420         CArrayFixFlat<TTimeIntervalSeconds>( 2 );

   421     CleanupStack::PushL( mArray );

   422     

   423     TTimeIntervalSeconds dura1( KDurationOne );

   424     TTimeIntervalSeconds dura2( KDurationTwo );

   425     

   426     mArray->AppendL( dura1 );

   427     mArray->AppendL( dura2 );

   428     

   429     durationArray->SetArray( *mArray );

   430     

   431     TInt size = durationArray->FormattedStringSize();

   432     STIF_ASSERT_NOT_EQUALS( KZero, size );

   433     

   434     CleanupStack::Pop( mArray );

   435     CleanupStack::PopAndDestroy( durationArray );

   436     return KErrNone;

   437     }

   438 

   439 // -----------------------------------------------------------------------------

   440 // CTestSDKQueries::TestQVDArrayFormatDurationL

   441 // -----------------------------------------------------------------------------

   442 //

   443 TInt CTestSDKQueries::TestQVDArrayFormatDurationL( CStifItemParser& /*aItem*/ )

   444     {

   445     CAknQueryValueDurationArray* durationArray = 

   446         CAknQueryValueDurationArray::NewLC( R_TESTQUERY_TIME_FORMAT );

   447     

   448     CArrayFix<TTimeIntervalSeconds>* mArray = new( ELeave ) 

   449         CArrayFixFlat<TTimeIntervalSeconds>( 2 );

   450     CleanupStack::PushL( mArray );

   451     

   452     TTimeIntervalSeconds dura1( KDurationOne );

   453     TTimeIntervalSeconds dura2( KDurationTwo );

   454     

   455     mArray->AppendL( dura1 );

   456     mArray->AppendL( dura2 );

   457     

   458     durationArray->SetArray( *mArray );

   459     

   460     TBufC< KBufSize > formatText;

   461     TPtr ptr( formatText.Des() );

   462     TTimeIntervalSeconds dura = KTimeIntervalSeconds;

   463     

   464     durationArray->FormatDuration( ptr, dura );

   465     

   466     CleanupStack::Pop( mArray );

   467     CleanupStack::PopAndDestroy( durationArray );

   468     return KErrNone;

   469     }

   470 

   471 // -----------------------------------------------------------------------------

   472 // CTestSDKQueries::TestQVDArrayMdcaCountL

   473 // -----------------------------------------------------------------------------

   474 //

   475 TInt CTestSDKQueries::TestQVDArrayMdcaCountL( CStifItemParser& aItem )

   476     {

   477     TInt err = TestQVDArrayMdcaPointL( aItem );

   478     return err;

   479     }

   480 

   481 // -----------------------------------------------------------------------------

   482 // CTestSDKQueries::TestQVDArrayMdcaPointL

   483 // -----------------------------------------------------------------------------

   484 //

   485 TInt CTestSDKQueries::TestQVDArrayMdcaPointL( CStifItemParser& /*aItem*/ )

   486     {

   487     CAknQueryValueDurationArray* durationArray = 

   488         CAknQueryValueDurationArray::NewLC( R_TESTQUERY_TIME_FORMAT );

   489     

   490     CArrayFix<TTimeIntervalSeconds>* mArray = new( ELeave ) 

   491         CArrayFixFlat<TTimeIntervalSeconds>( 2 );

   492     CleanupStack::PushL( mArray );

   493     

   494     TTimeIntervalSeconds dura1( KDurationOne );

   495     TTimeIntervalSeconds dura2( KDurationTwo );

   496     

   497     mArray->AppendL( dura1 );

   498     mArray->AppendL( dura2 );

   499     

   500     durationArray->SetArray( *mArray );

   501     

   502     for ( TInt mark = 0; mark < durationArray->MdcaCount(); mark++ )

   503         {

   504         TPtrC text = durationArray->MdcaPoint( mark );

   505         STIF_ASSERT_NOT_NULL( &text );

   506         }

   507     

   508     CleanupStack::Pop( mArray );

   509     CleanupStack::PopAndDestroy( durationArray );

   510     return KErrNone;

   511     }

   512 

   513 //End file

   514 

   515