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

    15 *

    16 */

    17 

    18 //INCLUDE

    19 #include <aknqueryvaluedate.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 

    29 // -----------------------------------------------------------------------------

    30 // CTestSDKQueries::TestQVSetQueryModeL

    31 // -----------------------------------------------------------------------------

    32 //

    33 TInt CTestSDKQueries::TestQVDNewL( CStifItemParser& /*aItem*/ )

    34     {

    35     CAknQueryValueDate* date = CAknQueryValueDate::NewL();

    36     CleanupStack::PushL( date );

    37     

    38     STIF_ASSERT_NOT_NULL( date );

    39     

    40     CleanupStack::PopAndDestroy( date );

    41     return KErrNone;

    42     }

    43 

    44 // -----------------------------------------------------------------------------

    45 // CTestSDKQueries::TestQVSetQueryModeL

    46 // -----------------------------------------------------------------------------

    47 //

    48 TInt CTestSDKQueries::TestQVDNewLCL( CStifItemParser& /*aItem*/ )

    49     {

    50     CAknQueryValueDate* date = CAknQueryValueDate::NewLC();

    51     

    52     STIF_ASSERT_NOT_NULL( date );

    53     

    54     CleanupStack::PopAndDestroy( date );

    55     return KErrNone;

    56     }

    57 

    58 // -----------------------------------------------------------------------------

    59 // CTestSDKQueries::TestQVSetQueryModeL

    60 // -----------------------------------------------------------------------------

    61 //

    62 TInt CTestSDKQueries::TestQVDDestructorL( CStifItemParser& /*aItem*/ )

    63     {

    64     CAknQueryValueDate* date = CAknQueryValueDate::NewLC();

    65     CleanupStack::PopAndDestroy( date );

    66     

    67     return KErrNone;

    68     }

    69 

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

    71 // CTestSDKQueries::TestQVSetQueryModeL

    72 // -----------------------------------------------------------------------------

    73 //

    74 TInt CTestSDKQueries::TestQVDSetArrayL( CStifItemParser& /*aItem*/ )

    75     {

    76     CAknQueryValueDate* date = CAknQueryValueDate::NewL();

    77     CleanupStack::PushL( date );

    78     

    79     CAknQueryValueDateArray* dateArray = CAknQueryValueDateArray::NewL( R_TESTQUERY_DATE_FORMAT );

    80     CleanupStack::PushL( dateArray );

    81     

    82     date->SetArrayL( dateArray );

    83     

    84     CleanupStack::Pop( dateArray );

    85     CleanupStack::PopAndDestroy( date );

    86     return KErrNone;

    87     }

    88 

    89 // -----------------------------------------------------------------------------

    90 // CTestSDKQueries::TestQVSetQueryModeL

    91 // -----------------------------------------------------------------------------

    92 //

    93 TInt CTestSDKQueries::TestQVDSetQueryCaptionL( CStifItemParser& /*aItem*/ )

    94     {

    95     CAknQueryValueDate* date = CAknQueryValueDate::NewL();

    96     CleanupStack::PushL( date );

    97     

    98     date->SetQueryCaption( R_TESTQUERY_CAPTION );

    99     

   100     CleanupStack::PopAndDestroy( date );

   101     return KErrNone;

   102     }

   103 

   104 // -----------------------------------------------------------------------------

   105 // CTestSDKQueries::TestQVSetQueryModeL

   106 // -----------------------------------------------------------------------------

   107 //

   108 TInt CTestSDKQueries::TestQVDValueL( CStifItemParser& /*aItem*/ )

   109     {

   110     CAknQueryValueDate* date = CAknQueryValueDate::NewL();

   111     CleanupStack::PushL( date );

   112     

   113     TTime compareTime( KZero );

   114     TTime returnTime = date->Value();

   115     STIF_ASSERT_EQUALS( compareTime, returnTime );

   116     

   117     CleanupStack::PopAndDestroy( date );

   118     return KErrNone;

   119     }

   120 

   121 // -----------------------------------------------------------------------------

   122 // CTestSDKQueries::TestQVSetQueryModeL

   123 // -----------------------------------------------------------------------------

   124 //

   125 TInt CTestSDKQueries::TestQVDMdcArrayL( CStifItemParser& /*aItem*/ )

   126     {

   127     CAknQueryValueDate* date = CAknQueryValueDate::NewL();

   128     CleanupStack::PushL( date );

   129     

   130     const MDesCArray* returnArray = date->MdcArray();

   131     STIF_ASSERT_NULL( returnArray );

   132     

   133     CAknQueryValueDateArray* dateArray = CAknQueryValueDateArray::NewL( R_TESTQUERY_DATE_FORMAT );

   134     CleanupStack::PushL( dateArray );

   135         

   136     date->SetArrayL( dateArray );

   137     

   138     const MDesCArray* returnArrayTwo = date->MdcArray();

   139     

   140     STIF_ASSERT_EQUALS( dateArray, ( CAknQueryValueDateArray* )returnArrayTwo );

   141     

   142     CleanupStack::Pop( dateArray );

   143     CleanupStack::PopAndDestroy( date );

   144     return KErrNone;

   145     }

   146 

   147 // -----------------------------------------------------------------------------

   148 // CTestSDKQueries::TestQVSetQueryModeL

   149 // -----------------------------------------------------------------------------

   150 //

   151 TInt CTestSDKQueries::TestQVDCurrentValueTextLCL( CStifItemParser& /*aItem*/ )

   152     {

   153     CAknQueryValueDate* date = CAknQueryValueDate::NewL();

   154     CleanupStack::PushL( date );

   155     

   156     CAknQueryValueDateArray* dateArray = CAknQueryValueDateArray::NewL( R_TESTQUERY_DATE_FORMAT );

   157     CleanupStack::PushL( dateArray );

   158     

   159     CArrayFix<TTime>* timeArray = new( ELeave ) CArrayFixFlat<TTime>( 4 );

   160     CleanupStack::PushL( timeArray );

   161     

   162     TTime time1;

   163     time1.HomeTime();

   164     TTime time2;

   165     time2 = time1 + TTimeIntervalDays( 3 );

   166     

   167     timeArray->AppendL( time1 );

   168     timeArray->AppendL( time2 );

   169     

   170     dateArray->SetArray( *timeArray );

   171     

   172     date->SetArrayL( dateArray );

   173     

   174     HBufC* text = date->CurrentValueTextLC();

   175     STIF_ASSERT_NOT_NULL( text );

   176     

   177     CleanupStack::Pop( KThree );

   178     CleanupStack::PopAndDestroy( date );

   179     return KErrNone;

   180     }

   181 

   182 // -----------------------------------------------------------------------------

   183 // CTestSDKQueries::TestQVSetQueryModeL

   184 // -----------------------------------------------------------------------------

   185 //

   186 TInt CTestSDKQueries::TestQVDCurrentValueIndexL( CStifItemParser& /*aItem*/ )

   187     {

   188     CAknQueryValueDate* date = CAknQueryValueDate::NewL();

   189     CleanupStack::PushL( date );

   190     

   191     TInt mIndex = date->CurrentValueIndex();

   192     STIF_ASSERT_EQUALS( KZero, mIndex );

   193     

   194     CAknQueryValueDateArray* dateArray = CAknQueryValueDateArray::NewL( R_TESTQUERY_DATE_FORMAT );

   195     CleanupStack::PushL( dateArray );

   196     

   197     CArrayFix<TTime>* timeArray = new( ELeave ) CArrayFixFlat<TTime>( 4 );

   198     CleanupStack::PushL( timeArray );

   199     

   200     TTime time1;

   201     time1.HomeTime();

   202     TTime time2;

   203     time2 = time1 + TTimeIntervalDays( 3 );

   204     

   205     timeArray->AppendL( time1 );

   206     timeArray->AppendL( time2 );

   207     

   208     dateArray->SetArray( *timeArray );

   209     

   210     date->SetArrayL( dateArray );

   211     

   212     date->SetCurrentValueIndex( KOne );

   213     

   214     mIndex = date->CurrentValueIndex();

   215     STIF_ASSERT_EQUALS( KOne, mIndex );

   216     

   217     CleanupStack::Pop( KTwo );

   218     CleanupStack::PopAndDestroy( date );

   219     return KErrNone;

   220     }

   221 

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

   223 // CTestSDKQueries::TestQVSetQueryModeL

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

   225 //

   226 TInt CTestSDKQueries::TestQVDSetCurrentValueIndexL( CStifItemParser& aItem )

   227     {

   228     TInt err = TestQVDCurrentValueIndexL( aItem );

   229     return err;

   230     }

   231 

   232 // -----------------------------------------------------------------------------

   233 // CTestSDKQueries::TestQVSetQueryModeL

   234 // -----------------------------------------------------------------------------

   235 //

   236 TInt CTestSDKQueries::TestQVDCreateEditorL( CStifItemParser& /*aItem*/ )

   237     {

   238     CAknQueryValueDate* date = CAknQueryValueDate::NewL();

   239     CleanupStack::PushL( date );

   240     

   241     CAknQueryValueDateArray* dateArray = CAknQueryValueDateArray::NewL( R_TESTQUERY_DATE_FORMAT );

   242     CleanupStack::PushL( dateArray );

   243     

   244     CArrayFix<TTime>* timeArray = new( ELeave ) CArrayFixFlat<TTime>( 4 );

   245     CleanupStack::PushL( timeArray );

   246     

   247     TTime time1;

   248     time1.HomeTime();

   249     TTime time2;

   250     time2 = time1 + TTimeIntervalDays( 3 );

   251     

   252     timeArray->AppendL( time1 );

   253     timeArray->AppendL( time2 );

   254     

   255     dateArray->SetArray( *timeArray );

   256     

   257     date->SetArrayL( dateArray );

   258 

   259     date->SetCurrentValueIndex( KZero );

   260     

   261     TBool flag = date->CreateEditorL();

   262     STIF_ASSERT_TRUE( flag );

   263     

   264     CleanupStack::Pop( KTwo );

   265     CleanupStack::PopAndDestroy( date );

   266     return KErrNone;

   267     }

   268 

   269 // -----------------------------------------------------------------------------

   270 // CTestSDKQueries::TestQVDANewL

   271 // -----------------------------------------------------------------------------

   272 //

   273 TInt CTestSDKQueries::TestQVDANewL( CStifItemParser& /*aItem*/ )

   274     {

   275     CAknQueryValueDateArray* dateArray = CAknQueryValueDateArray::NewL( R_TESTQUERY_DATE_FORMAT );

   276     CleanupStack::PushL( dateArray );

   277     

   278     STIF_ASSERT_NOT_NULL( dateArray );

   279     

   280     CleanupStack::PopAndDestroy( dateArray );

   281     return KErrNone;

   282     }

   283 

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

   285 // CTestSDKQueries::TestQVDANewLCL

   286 // -----------------------------------------------------------------------------

   287 //

   288 TInt CTestSDKQueries::TestQVDANewLCL( CStifItemParser& /*aItem*/ )

   289     {

   290     CAknQueryValueDateArray* dateArray = CAknQueryValueDateArray::NewLC( R_TESTQUERY_DATE_FORMAT );

   291     

   292     STIF_ASSERT_NOT_NULL( dateArray );

   293     

   294     CleanupStack::PopAndDestroy( dateArray );

   295     return KErrNone;

   296     }

   297 

   298 // -----------------------------------------------------------------------------

   299 // CTestSDKQueries::TestQVDADestructorL

   300 // -----------------------------------------------------------------------------

   301 //

   302 TInt CTestSDKQueries::TestQVDADestructorL( CStifItemParser& /*aItem*/ )

   303     {

   304     CAknQueryValueDateArray* dateArray = CAknQueryValueDateArray::NewLC( R_TESTQUERY_DATE_FORMAT );

   305     CleanupStack::PopAndDestroy( dateArray );

   306     

   307     return KErrNone;

   308     }

   309 

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

   311 // CTestSDKQueries::TestQVDASetArrayL

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

   313 //

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

   315     {

   316     CAknQueryValueDateArray* dateArray = CAknQueryValueDateArray::NewL( R_TESTQUERY_DATE_FORMAT );

   317     CleanupStack::PushL( dateArray );

   318     

   319     CArrayFix<TTime>* timeArray = new( ELeave ) CArrayFixFlat<TTime>( 4 );

   320     CleanupStack::PushL( timeArray );

   321     

   322     TTime time1;

   323     time1.HomeTime();

   324     TTime time2;

   325     time2 = time1 + TTimeIntervalDays( 3 );

   326     

   327     timeArray->AppendL( time1 );

   328     timeArray->AppendL( time2 );

   329     

   330     dateArray->SetArray( *timeArray );

   331     

   332     CleanupStack::Pop( timeArray );

   333     CleanupStack::PopAndDestroy( dateArray );

   334     return KErrNone;

   335     }

   336 

   337 // -----------------------------------------------------------------------------

   338 // CTestSDKQueries::TestQVDAArrayL

   339 // -----------------------------------------------------------------------------

   340 //

   341 TInt CTestSDKQueries::TestQVDAArrayL( CStifItemParser& /*aItem*/ )

   342     {

   343     CAknQueryValueDateArray* dateArray = CAknQueryValueDateArray::NewL( R_TESTQUERY_DATE_FORMAT );

   344     CleanupStack::PushL( dateArray );

   345     

   346     CArrayFix<TTime>* returnArray = dateArray->Array();

   347     STIF_ASSERT_NULL( returnArray );

   348     

   349     CArrayFix<TTime>* timeArray = new( ELeave ) CArrayFixFlat<TTime>( 4 );

   350     CleanupStack::PushL( timeArray );

   351     

   352     TTime time1;

   353     time1.HomeTime();

   354     TTime time2;

   355     time2 = time1 + TTimeIntervalDays( 3 );

   356     

   357     timeArray->AppendL( time1 );

   358     timeArray->AppendL( time2 );

   359     

   360     dateArray->SetArray( *timeArray );

   361     

   362     returnArray = dateArray->Array();

   363     STIF_ASSERT_EQUALS( timeArray, returnArray );

   364     

   365     CleanupStack::Pop( timeArray );

   366     CleanupStack::PopAndDestroy( dateArray );

   367     return KErrNone;

   368     }

   369 

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

   371 // CTestSDKQueries::TestQVDAFormatStringL

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

   373 //

   374 TInt CTestSDKQueries::TestQVDAFormatStringL( CStifItemParser& /*aItem*/ )

   375     {

   376     CAknQueryValueDateArray* dateArray = CAknQueryValueDateArray::NewL( R_TESTQUERY_DATE_FORMAT );

   377     CleanupStack::PushL( dateArray );

   378     

   379     CArrayFix<TTime>* timeArray = new( ELeave ) CArrayFixFlat<TTime>( 4 );

   380     CleanupStack::PushL( timeArray );

   381     

   382     TTime time1;

   383     time1.HomeTime();

   384     TTime time2;

   385     time2 = time1 + TTimeIntervalDays( 3 );

   386     

   387     timeArray->AppendL( time1 );

   388     timeArray->AppendL( time2 );

   389     

   390     dateArray->SetArray( *timeArray );

   391     

   392     const HBufC* buf = dateArray->FormatString();

   393     STIF_ASSERT_NOT_NULL( buf );

   394     

   395     CleanupStack::Pop( timeArray );

   396     CleanupStack::PopAndDestroy( dateArray );

   397     return KErrNone;

   398     }

   399 

   400 // -----------------------------------------------------------------------------

   401 // CTestSDKQueries::TestQVDAFormattedStringSizeOneL

   402 // -----------------------------------------------------------------------------

   403 //

   404 TInt CTestSDKQueries::TestQVDAFormattedStringSizeOneL( CStifItemParser& /*aItem*/ )

   405     {

   406     CAknQueryValueDateArray* dateArray = CAknQueryValueDateArray::NewL( R_TESTQUERY_DATE_FORMAT );

   407     CleanupStack::PushL( dateArray );

   408     

   409     CArrayFix<TTime>* timeArray = new( ELeave ) CArrayFixFlat<TTime>( 4 );

   410     CleanupStack::PushL( timeArray );

   411     

   412     TTime time1;

   413     time1.HomeTime();

   414     TTime time2;

   415     time2 = time1 + TTimeIntervalDays( 3 );

   416     

   417     timeArray->AppendL( time1 );

   418     timeArray->AppendL( time2 );

   419     

   420     dateArray->SetArray( *timeArray );

   421     

   422     const TInt size = dateArray->FormattedStringSize();

   423     STIF_ASSERT_NOT_EQUALS( KZero, size );

   424     

   425     CleanupStack::Pop( timeArray );

   426     CleanupStack::PopAndDestroy( dateArray );

   427     return KErrNone;

   428     }

   429 

   430 // -----------------------------------------------------------------------------

   431 // CTestSDKQueries::TestQVDAFormattedStringSizeTwoL

   432 // -----------------------------------------------------------------------------

   433 //

   434 TInt CTestSDKQueries::TestQVDAFormattedStringSizeTwoL( CStifItemParser& /*aItem*/ )

   435     {

   436     CAknQueryValueDateArray* dateArray = CAknQueryValueDateArray::NewL( R_TESTQUERY_DATE_FORMAT );

   437     CleanupStack::PushL( dateArray );

   438     

   439     CArrayFix<TTime>* timeArray = new( ELeave ) CArrayFixFlat<TTime>( 4 );

   440     CleanupStack::PushL( timeArray );

   441     

   442     TTime time1;

   443     time1.HomeTime();

   444     TTime time2;

   445     time2 = time1 + TTimeIntervalDays( 3 );

   446     

   447     timeArray->AppendL( time1 );

   448     timeArray->AppendL( time2 );

   449     

   450     dateArray->SetArray( *timeArray );

   451     

   452     TInt size = dateArray->FormattedStringSize();

   453     STIF_ASSERT_NOT_EQUALS( KZero, size );

   454     

   455     CleanupStack::Pop( timeArray );

   456     CleanupStack::PopAndDestroy( dateArray );

   457     return KErrNone;

   458     }

   459 

   460 // -----------------------------------------------------------------------------

   461 // CTestSDKQueries::TestQVDAMdcaCountL

   462 // -----------------------------------------------------------------------------

   463 //

   464 TInt CTestSDKQueries::TestQVDAMdcaCountL( CStifItemParser& /*aItem*/ )

   465     {

   466     CAknQueryValueDateArray* dateArray = CAknQueryValueDateArray::NewL( R_TESTQUERY_DATE_FORMAT );

   467     CleanupStack::PushL( dateArray );

   468     

   469     CArrayFix<TTime>* timeArray = new( ELeave ) CArrayFixFlat<TTime>( 4 );

   470     CleanupStack::PushL( timeArray );

   471     

   472     TTime time1;

   473     time1.HomeTime();

   474     TTime time2;

   475     time2 = time1 + TTimeIntervalDays( 3 );

   476     

   477     timeArray->AppendL( time1 );

   478     timeArray->AppendL( time2 );

   479     

   480     dateArray->SetArray( *timeArray );

   481         

   482     TInt count = dateArray->MdcaCount();

   483     STIF_ASSERT_NOT_EQUALS( KZero, count );

   484     

   485     CleanupStack::Pop( timeArray );

   486     CleanupStack::PopAndDestroy( dateArray );

   487     return KErrNone;

   488     }

   489 

   490 // -----------------------------------------------------------------------------

   491 // CTestSDKQueries::TestQVDAMdcaPointL

   492 // -----------------------------------------------------------------------------

   493 //

   494 TInt CTestSDKQueries::TestQVDAMdcaPointL( CStifItemParser& /*aItem*/ )

   495     {

   496     CAknQueryValueDateArray* dateArray = CAknQueryValueDateArray::NewL( R_TESTQUERY_DATE_FORMAT );

   497     CleanupStack::PushL( dateArray );

   498     

   499     CArrayFix<TTime>* timeArray = new( ELeave ) CArrayFixFlat<TTime>( 4 );

   500     CleanupStack::PushL( timeArray );

   501     

   502     TTime time1;

   503     time1.HomeTime();

   504     TTime time2;

   505     time2 = time1 + TTimeIntervalDays( 3 );

   506     

   507     timeArray->AppendL( time1 );

   508     timeArray->AppendL( time2 );

   509     

   510     dateArray->SetArray( *timeArray );

   511     

   512     for ( TInt mark = 0; mark < dateArray->MdcaCount(); mark++ )

   513         {

   514         TPtrC text = dateArray->MdcaPoint( mark );

   515         STIF_ASSERT_NOT_NULL( &text );

   516         }

   517     

   518     CleanupStack::Pop( timeArray );

   519     CleanupStack::PopAndDestroy( dateArray );

   520     return KErrNone;

   521     }

   522 

   523 //End file

   524 

   525