1 /*

     2 * Copyright (c) 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:  Implementation of CLF API test 

    15 *

    16 */

    17 

    18 

    19 // INCLUDES

    20 #include "T_CLFApiModuleTests.h"

    21 #include <s32mem.h> 

    22 #include <eunitmacros.h>

    23 

    24 // the header for the tested class

    25 #include <ContentListingFactory.h>

    26 #include <MCLFChangedItemObserver.h>

    27 #include <MCLFContentListingEngine.h>

    28 #include <MCLFCustomGrouper.h>

    29 #include <MCLFCustomSorter.h>

    30 #include <MCLFItem.h>

    31 #include <MCLFItemListModel.h>

    32 #include <MCLFModifiableItem.h>

    33 #include <MCLFOperationObserver.h>

    34 #include <MCLFPostFilter.h>

    35 #include <MCLFSortingStyle.h>

    36 #include <T_ContentListingFramework.rsg>

    37 #include <collate.h>

    38 #include <PathInfo.h>

    39 #include <MCLFProcessObserver.h>

    40 #include <CLFContentListingExtended.hrh>

    41 

    42 //CONSTS

    43 #ifdef __WINSCW__

    44 _LIT( KTestResourceFile, "z:\\resource\\T_ContentListingFramework.rsc" );

    45 #else

    46 _LIT( KTestResourceFile, "c:\\sys\\bin\\T_ContentListingFramework.rsc" );

    47 #endif

    48 _LIT( KTestFileNameBase, "CLFTestFiles\\TestFile" );

    49 _LIT( KTestFileExt, ".txt" );

    50 

    51 const TCLFFieldId KMultibleSortingTestField1 = 0x80000001;

    52 const TCLFFieldId KMultibleSortingTestField2 = 0x80000002;

    53 const TCLFFieldId KMultibleSortingTestField3 = 0x80000003;

    54 const TCLFFieldId KMultibleSortingTestField4 = 0x80000004;

    55 const TCLFFieldId KMultibleSortingTestField5 = 0x80000005;

    56 const TCLFFieldId KMultibleSortingTestField6 = 0x80000006;

    57 

    58 const TInt KCLFUpdateFoldersSemanticId = 0x1000;

    59 

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

    61 // class CMGXAsyncCallback

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

    63 //

    64 class CCLFAsyncCallback : public CBase

    65     {

    66     public:

    67         ~CCLFAsyncCallback()

    68             {

    69             if ( iActiveWait.IsStarted() )

    70                 {

    71                 iActiveWait.AsyncStop();

    72                 }

    73             }

    74     public:

    75         static void AfterL( TTimeIntervalMicroSeconds32 aInterval )

    76             {

    77             CCLFAsyncCallback* self = new( ELeave ) CCLFAsyncCallback();

    78             CleanupStack::PushL( self );

    79             CPeriodic* periodic = CPeriodic::NewL( CActive::EPriorityIdle );

    80             CleanupStack::PushL( periodic );

    81             TCallBack callBack( CallBackL, self );

    82             TTimeIntervalMicroSeconds32 interval( 1000000 );

    83             periodic->Start( aInterval, aInterval, callBack );

    84             self->iActiveWait.Start();

    85             periodic->Cancel();

    86             CleanupStack::PopAndDestroy( 2 ); // periodic, self

    87             }

    88 

    89         static TInt CallBackL( TAny* aObject )

    90             {

    91             CCLFAsyncCallback* self = reinterpret_cast< CCLFAsyncCallback* >( aObject );

    92             if ( self->iActiveWait.IsStarted() )

    93                 {

    94                 self->iActiveWait.AsyncStop();

    95                 }

    96             return EFalse;

    97             }

    98             

    99     private:

   100         CActiveSchedulerWait iActiveWait;

   101     };

   102 

   103 // ---------------------------------------------------------------------------

   104 // class TTestOperationObserver

   105 // ---------------------------------------------------------------------------

   106 //

   107 class TTestOperationObserver : public MCLFOperationObserver

   108     {

   109     public:

   110         TTestOperationObserver()

   111             // set invalid values

   112             : iOperationEvent( TCLFOperationEvent( -1 ) ), iError( 1 ), iWait( NULL )

   113             {}

   114         void HandleOperationEventL( TCLFOperationEvent aOperationEvent,

   115                                     TInt aError )

   116             {

   117             iError = aError;

   118             iOperationEvent = aOperationEvent;

   119             if( iWait &&

   120                 iWait->IsStarted() )

   121                 {

   122                 iWait->AsyncStop();

   123                 }

   124             }

   125         TCLFOperationEvent iOperationEvent;

   126         TInt iError;

   127         CActiveSchedulerWait* iWait;

   128 

   129     };

   130 

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

   132 // class TTestCustomSorter

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

   134 //

   135 class TTestCustomSorter : public MCLFCustomSorter

   136     {

   137     public:

   138         TTestCustomSorter() : iSortItems( EFalse )

   139             {

   140             }

   141         void SortItemsL( RPointerArray<MCLFItem>& /*aItemArray*/ )

   142             {

   143             //aItemArray;

   144             iSortItems = ETrue;

   145             }

   146         TBool iSortItems;

   147 

   148     };

   149 

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

   151 // class TTestCustomGrouper

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

   153 //

   154 class TTestCustomGrouper : public MCLFCustomGrouper

   155     {

   156     public:

   157         TTestCustomGrouper() : iGroupCount( 2 ), iCopyItems( EFalse ), iModifiableItems( NULL )

   158             {

   159             }

   160         void GroupItemsL( const TArray<MCLFItem*>& /*aSourceList*/,

   161                           RPointerArray<MCLFItem>& aGroupedList )

   162             {

   163             //aSourceList;

   164             if( iCopyItems )

   165                 {

   166                 TInt count( iModifiableItems->Count() );

   167                 for( TInt i = 0 ; i < count ; ++i )

   168                     {

   169                     aGroupedList.AppendL( (*iModifiableItems)[i] );

   170                     }

   171                 }

   172             else if( iModifiableItems )

   173                 {

   174                 iModifiableItems->ResetAndDestroy();

   175                 for( TInt i = 0 ; i < iGroupCount ; ++i )

   176                     {

   177                     MCLFModifiableItem* item = ContentListingFactory::NewModifiableItemLC();

   178                     iModifiableItems->AppendL( item );

   179                     CleanupStack::Pop(); // item

   180                     aGroupedList.AppendL( item );

   181                     }

   182                 }

   183             }

   184         TInt iGroupCount;

   185         TBool iCopyItems;

   186         RPointerArray<MCLFModifiableItem>* iModifiableItems;

   187     };

   188 

   189 // ---------------------------------------------------------------------------

   190 // class TTestPostFilter

   191 // ---------------------------------------------------------------------------

   192 //

   193 class TTestPostFilter : public MCLFPostFilter

   194     {

   195     public:

   196         TTestPostFilter() : iShouldFilterCount( 5 ), iAllFilter( EFalse )

   197             {

   198             }

   199 

   200         void FilterItemsL( const TArray<MCLFItem*>& aItemList,

   201                            RPointerArray<MCLFItem>& aFilteredItemList )

   202             {

   203             iFilteredCount = 0;

   204             if( iAllFilter )

   205                 {

   206                 iFilteredCount = aItemList.Count();

   207                 return;

   208                 }

   209             for( TInt i = 0 ; i < aItemList.Count() ; ++i )

   210                 {

   211                 if( i < iShouldFilterCount  )

   212                     {

   213                     iFilteredCount++;

   214                     }

   215                 else

   216                     {

   217                     aFilteredItemList.AppendL( aItemList[i] );

   218                     }

   219                 }

   220             }

   221         TInt iShouldFilterCount;

   222         TBool iAllFilter;

   223         TInt iFilteredCount;

   224 

   225     };

   226 

   227 // ---------------------------------------------------------------------------

   228 // class TTestChangedItemObserver

   229 // ---------------------------------------------------------------------------

   230 //

   231 class TTestChangedItemObserver : public MCLFChangedItemObserver

   232     {

   233     public:

   234         TTestChangedItemObserver()

   235             : iHandleItemChange( EFalse ),

   236               iLastError( KErrNone ),

   237               iChangedArray( NULL ),

   238               iWait( NULL )      

   239             {

   240             }

   241         void HandleItemChangeL( const TArray<TCLFItemId>& aItemIDArray )

   242             {

   243             iHandleItemChange = ETrue;

   244             if( iChangedArray )

   245                 {

   246                 iChangedArray->Reset();

   247                 for( TInt i = 0 ; i < aItemIDArray.Count() ; ++i )

   248                     {

   249                     iChangedArray->AppendL( aItemIDArray[i] );

   250                     }

   251                 }

   252             if( iWait && iWait->IsStarted() )

   253                 {

   254                 iWait->AsyncStop();

   255                 }

   256 

   257             }

   258         void HandleError( TInt aError )

   259             {

   260             iLastError = aError;

   261             if( iWait && iWait->IsStarted() )

   262                 {

   263                 iWait->AsyncStop();

   264                 }

   265             }

   266         TInt iHandleItemChange;

   267         TInt iLastError;

   268         RArray<TCLFItemId>* iChangedArray;

   269         CActiveSchedulerWait* iWait;

   270     };

   271 

   272 // ---------------------------------------------------------------------------

   273 // class TTestCLFProcessObserver

   274 // ---------------------------------------------------------------------------

   275 //

   276 class TTestCLFProcessObserver : public MCLFProcessObserver

   277     {

   278     public:

   279         TTestCLFProcessObserver()

   280             : iStartEvent( EFalse ), iEndEvent( EFalse )

   281             {}

   282         void HandleCLFProcessEventL( TCLFProcessEvent aProcessEvent )

   283             {

   284             switch ( aProcessEvent )

   285                 {

   286                 case ECLFUpdateStart:

   287                     {

   288                     iStartEvent = ETrue;

   289                     break;

   290                     }

   291                 case ECLFUpdateStop:

   292                     {

   293                     iEndEvent = ETrue;

   294                     break;

   295                     }

   296                 default:

   297                     {

   298                     User::Panic( _L("CLF module test"), 1 );

   299                     }

   300                 }

   301             }

   302         void Reset()

   303             {

   304             iStartEvent = EFalse;

   305             iEndEvent = EFalse;

   306             }

   307         TBool iStartEvent;

   308         TBool iEndEvent;

   309     };

   310 

   311 void SerializeL( const MDesCArray& aDataArray, CBufBase& aBuffer )

   312     {

   313     const TInt count( aDataArray.MdcaCount() );

   314     RBufWriteStream writeStream( aBuffer );

   315     CleanupClosePushL( writeStream );

   316     writeStream.WriteInt32L( count );

   317     for( TInt i = 0 ; i < count ; ++i )

   318         {

   319         const TDesC& des = aDataArray.MdcaPoint( i );

   320         TInt length( des.Length() );

   321         writeStream.WriteInt32L( length );

   322         writeStream.WriteL( des, length );

   323         }

   324     CleanupStack::PopAndDestroy( &writeStream );

   325     }

   326 

   327 // ---------------------------------------------------------------------------

   328 // T_CLFApiModuleTests::NewLC()

   329 // Create the testing class

   330 // ---------------------------------------------------------------------------

   331 //

   332 T_CLFApiModuleTests* T_CLFApiModuleTests::NewLC()

   333     {

   334     T_CLFApiModuleTests* self = new(ELeave) T_CLFApiModuleTests;

   335 

   336     CleanupStack::PushL( self );

   337     // need to generate the table, so call base classes

   338     // second phase constructor

   339     self->ConstructL();

   340     return self;

   341     }

   342 

   343 

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

   345 // T_CLFApiModuleTests::ConstructL()

   346 // ---------------------------------------------------------------------------

   347 //

   348 void T_CLFApiModuleTests::ConstructL()

   349     {

   350     CEUnitTestSuiteClass::ConstructL();

   351     }

   352 

   353 // ---------------------------------------------------------------------------

   354 // T_CLFApiModuleTests::~T_CLFApiModuleTests()

   355 // ---------------------------------------------------------------------------

   356 //

   357 T_CLFApiModuleTests::~T_CLFApiModuleTests()

   358     {

   359     Teardown();

   360     }

   361 

   362 /**

   363  * Assistance methods

   364  */

   365 

   366 // ---------------------------------------------------------------------------

   367 // T_CLFApiModuleTests::ResourceL

   368 // ---------------------------------------------------------------------------

   369 //

   370 void T_CLFApiModuleTests::ResourceL( TInt aResourceId )

   371     {

   372     delete iDataBuffer;

   373     iDataBuffer = NULL;

   374     iDataBuffer = iResourceFile.AllocReadL( aResourceId );

   375     iResourceReader.SetBuffer( iDataBuffer );

   376     }

   377 

   378 // ---------------------------------------------------------------------------

   379 // T_CLFApiModuleTests::SortingStyleResourceL

   380 // ---------------------------------------------------------------------------

   381 //

   382 void T_CLFApiModuleTests::SortingStyleResourceL()

   383     {

   384     ResourceL( R_SORTING_STYLE );

   385     }

   386 

   387 // ---------------------------------------------------------------------------

   388 // T_CLFApiModuleTests::ListModelResourceL

   389 // ---------------------------------------------------------------------------

   390 //

   391 void T_CLFApiModuleTests::ListModelResourceL()

   392     {

   393     ResourceL( R_LIST_MODEL );

   394     }

   395 

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

   397 // T_CLFApiModuleTests::CreateNewFileL

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

   399 //

   400 void T_CLFApiModuleTests::CreateNewFileL( TInt aNumber, TDes& aFileName )

   401     {

   402     aFileName.Copy( PathInfo::PhoneMemoryRootPath() );

   403     aFileName.Append( KTestFileNameBase );

   404     TBuf<125> buf;

   405     buf.Num( aNumber );

   406     aFileName.Append( buf );

   407     aFileName.Append( KTestFileExt );

   408 

   409     RFile file;

   410     BaflUtils::EnsurePathExistsL( iFs, aFileName );

   411     TInt error( file.Replace( iFs, aFileName, EFileShareAny | EFileWrite ) );

   412     if( error == KErrNone )

   413         {

   414         error = file.Write( _L8("Test data") );

   415         }

   416     file.Close();

   417     User::LeaveIfError( error );

   418     }

   419 

   420 // ---------------------------------------------------------------------------

   421 // T_CLFApiModuleTests::FindTestFileIdL

   422 // ---------------------------------------------------------------------------

   423 //

   424 TCLFItemId T_CLFApiModuleTests::FindTestFileIdL( TInt aNumber )

   425     {

   426     TCLFItemId id( 0 );

   427     MCLFItemListModel* model = iEngine->CreateListModelLC( *iTestObserver );

   428     iMimeTypeArray->AppendL( _L("*") );

   429 

   430     iTestObserver->iWait = &iWait;

   431     model->SetWantedMimeTypesL( *iMimeTypeArray );

   432     model->RefreshL();

   433     iWait.Start();

   434 

   435     TFileName testFileName( PathInfo::PhoneMemoryRootPath() );

   436     testFileName.Append( KTestFileNameBase );

   437     TBuf<125> buf;

   438     buf.Num( aNumber );

   439     testFileName.Append( buf );

   440     testFileName.Append( KTestFileExt );

   441     for( TInt i = 0 ; i < model->ItemCount() ; ++i )

   442         {

   443         const MCLFItem& item = model->Item( i );

   444         TPtrC fileName;

   445         if( item.GetField( ECLFFieldIdFileNameAndPath, fileName ) != KErrNone )

   446             {

   447             continue;

   448             }

   449         if( fileName.CompareF( testFileName ) == 0 )

   450             {

   451             id = item.ItemId();

   452             break;

   453             }

   454         }

   455     CleanupStack::PopAndDestroy(); // model

   456     return id;

   457     }

   458 

   459 // ---------------------------------------------------------------------------

   460 // T_CLFApiModuleTests::CheckFileNameShortingL

   461 // ---------------------------------------------------------------------------

   462 //

   463 TBool T_CLFApiModuleTests::CheckFileNameShortingL()

   464     {

   465     TCollationMethod m = *Mem::CollationMethodByIndex( 0 );

   466     m.iFlags |= TCollationMethod::EIgnoreNone | TCollationMethod::EFoldCase;

   467 

   468     for( TInt i = 0 ; i < iListModel->ItemCount() -1 ; ++i )

   469         {

   470         const MCLFItem& item = iListModel->Item( i );

   471         const MCLFItem& item1 = iListModel->Item( i + 1 );

   472         TPtrC name;

   473         TPtrC name1;

   474 

   475         if( item.GetField( ECLFFieldIdFileName, name ) != KErrNone ||

   476             item1.GetField( ECLFFieldIdFileName, name1 ) != KErrNone )

   477             {

   478             return EFalse;

   479             }

   480         if( name.CompareC( name1, 3, &m ) > 0 )

   481             {

   482             return EFalse;

   483             }

   484         }

   485     return ETrue;

   486     }

   487 

   488 // ---------------------------------------------------------------------------

   489 // T_CLFApiModuleTests::CheckFileSizeShortingL

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

   491 //

   492 TBool T_CLFApiModuleTests::CheckFileSizeShortingL()

   493     {

   494     for( TInt i = 0 ; i < iListModel->ItemCount() -1 ; ++i )

   495         {

   496         const MCLFItem& item = iListModel->Item( i );

   497         const MCLFItem& item1 = iListModel->Item( i + 1 );

   498         TInt32 size;

   499         TInt32 size1;

   500         if( item.GetField( ECLFFieldIdFileSize, size ) != KErrNone ||

   501             item1.GetField( ECLFFieldIdFileSize, size1 ) != KErrNone )

   502             {

   503             return EFalse;

   504             }

   505         if( size < size1 )

   506             {

   507             return EFalse;

   508             }

   509         }

   510     return ETrue;

   511     }

   512 

   513 // ---------------------------------------------------------------------------

   514 // T_CLFApiModuleTests::CheckMultibleSortingShortingL

   515 // ---------------------------------------------------------------------------

   516 //

   517 TBool T_CLFApiModuleTests::CheckMultibleSortingShortingL()

   518     {

   519     const MCLFItem* item = &( iListModel->Item( 0 ) );

   520     TInt32 data( 0 );

   521     if( item->GetField( KMultibleSortingTestField2, data ) != KErrNone ||

   522         data != 5 )

   523         {

   524         return EFalse;

   525         }

   526     item = &( iListModel->Item( 1 ) );

   527     if( item->GetField( KMultibleSortingTestField2, data ) != KErrNone ||

   528         data != 4 )

   529         {

   530         return EFalse;

   531         }

   532     item = &( iListModel->Item( 2 ) );

   533     if( item->GetField( KMultibleSortingTestField2, data ) != KErrNone ||

   534         data != 3 )

   535         {

   536         return EFalse;

   537         }

   538     item = &( iListModel->Item( 3 ) );

   539     if( item->GetField( KMultibleSortingTestField3, data ) != KErrNone ||

   540         data != 6 )

   541         {

   542         return EFalse;

   543         }

   544     item = &( iListModel->Item( 4 ) );

   545     if( item->GetField( KMultibleSortingTestField3, data ) != KErrNone ||

   546         data != 7 )

   547         {

   548         return EFalse;

   549         }

   550     item = &( iListModel->Item( 5 ) );

   551     if( item->GetField( KMultibleSortingTestField3, data ) != KErrNone ||

   552         data != 8 )

   553         {

   554         return EFalse;

   555         }

   556     item = &( iListModel->Item( 6 ) );

   557     if( item->GetField( KMultibleSortingTestField4, data ) != KErrNone ||

   558         data != 9 )

   559         {

   560         return EFalse;

   561         }

   562     item = &( iListModel->Item( 7 ) );

   563     if( item->GetField( KMultibleSortingTestField4, data ) != KErrNone ||

   564         data != 10 )

   565         {

   566         return EFalse;

   567         }

   568     item = &( iListModel->Item( 8 ) );

   569     if( item->GetField( KMultibleSortingTestField4, data ) != KErrNone ||

   570         data != 11 )

   571         {

   572         return EFalse;

   573         }

   574 // unsorted start

   575     item = &( iListModel->Item( 9 ) );

   576     if( item->GetField( KMultibleSortingTestField6, data ) != KErrNone ||

   577         ( data < 15 || data > 17 ) )

   578         {

   579         return EFalse;

   580         }

   581     item = &( iListModel->Item( 10 ) );

   582     if( item->GetField( KMultibleSortingTestField6, data ) != KErrNone ||

   583         ( data < 15 || data > 17 ) )

   584         {

   585         return EFalse;

   586         }

   587     item = &( iListModel->Item( 11 ) );

   588     if( item->GetField( KMultibleSortingTestField6, data ) != KErrNone ||

   589         ( data < 15 || data > 17 ) )

   590         {

   591         return EFalse;

   592         }

   593 // unsorted end

   594     item = &( iListModel->Item( 12 ) );

   595     if( item->GetField( KMultibleSortingTestField5, data ) != KErrNone ||

   596         data != 12 )

   597         {

   598         return EFalse;

   599         }

   600     item = &( iListModel->Item( 13 ) );

   601     if( item->GetField( KMultibleSortingTestField5, data ) != KErrNone ||

   602         data != 13 )

   603         {

   604         return EFalse;

   605         }

   606     item = &( iListModel->Item( 14 ) );

   607     if( item->GetField( KMultibleSortingTestField5, data ) != KErrNone ||

   608         data != 14 )

   609         {

   610         return EFalse;

   611         }

   612     item = &( iListModel->Item( 15 ) );

   613     if( item->GetField( KMultibleSortingTestField1, data ) != KErrNone ||

   614         data != 0 )

   615         {

   616         return EFalse;

   617         }

   618     item = &( iListModel->Item( 16 ) );

   619     if( item->GetField( KMultibleSortingTestField1, data ) != KErrNone ||

   620         data != 1 )

   621         {

   622         return EFalse;

   623         }

   624     item = &( iListModel->Item( 17 ) );

   625     if( item->GetField( KMultibleSortingTestField1, data ) != KErrNone ||

   626         data != 2 )

   627         {

   628         return EFalse;

   629         }

   630 

   631     return ETrue;

   632     }

   633 

   634 // ---------------------------------------------------------------------------

   635 // T_CLFApiModuleTests::CheckMultibleSortingShorting2L

   636 // ---------------------------------------------------------------------------

   637 //

   638 TBool T_CLFApiModuleTests::CheckMultibleSortingShorting2L()

   639     {

   640 // check sorted

   641     const MCLFItem* item = &( iListModel->Item( 0 ) );

   642     TInt32 data( 0 );

   643     if( item->GetField( KMultibleSortingTestField5, data ) != KErrNone ||

   644         data != 12 )

   645         {

   646         return EFalse;

   647         }

   648     item = &( iListModel->Item( 1 ) );

   649     if( item->GetField( KMultibleSortingTestField5, data ) != KErrNone ||

   650         data != 13 )

   651         {

   652         return EFalse;

   653         }

   654     item = &( iListModel->Item( 2 ) );

   655     if( item->GetField( KMultibleSortingTestField5, data ) != KErrNone ||

   656         data != 14 )

   657         {

   658         return EFalse;

   659         }

   660     item = &( iListModel->Item( 3 ) );

   661     if( item->GetField( KMultibleSortingTestField6, data ) != KErrNone ||

   662         data != 15 )

   663         {

   664         return EFalse;

   665         }

   666     item = &( iListModel->Item( 4 ) );

   667     if( item->GetField( KMultibleSortingTestField6, data ) != KErrNone ||

   668         data != 16 )

   669         {

   670         return EFalse;

   671         }

   672     item = &( iListModel->Item( 5 ) );

   673     if( item->GetField( KMultibleSortingTestField6, data ) != KErrNone ||

   674         data != 17 )

   675         {

   676         return EFalse;

   677         }

   678 // check unsorted

   679     for( TInt i = 6 ; i < 18 ; ++i )

   680         {

   681         item = &( iListModel->Item( i ) );

   682         if( item->GetField( KMultibleSortingTestField1, data ) != KErrNone )

   683             {

   684             if( item->GetField( KMultibleSortingTestField2, data ) != KErrNone )

   685                 {

   686                 if( item->GetField( KMultibleSortingTestField3, data ) != KErrNone )

   687                     {

   688                     if( item->GetField( KMultibleSortingTestField4, data ) != KErrNone )

   689                         {

   690                         return EFalse;

   691                         }

   692                     }

   693                 }

   694             }

   695         if( data < 0 || data > 11 )

   696             {

   697             return EFalse;

   698             }

   699         }

   700 

   701     return ETrue;

   702     }

   703 

   704 // ---------------------------------------------------------------------------

   705 // T_CLFApiModuleTests::CheckFileDateShortingL

   706 // ---------------------------------------------------------------------------

   707 //

   708 TBool T_CLFApiModuleTests::CheckFileDateShortingL()

   709     {

   710     for( TInt i = 0 ; i < iListModel->ItemCount() -1 ; ++i )

   711         {

   712         const MCLFItem& item = iListModel->Item( i );

   713         const MCLFItem& item1 = iListModel->Item( i + 1 );

   714         TTime date;

   715         TTime date1;

   716         if( item.GetField( ECLFFieldIdFileDate, date ) != KErrNone ||

   717             item1.GetField( ECLFFieldIdFileDate, date1 ) != KErrNone )

   718             {

   719             return EFalse;

   720             }

   721         if( date > date1 )

   722             {

   723             return EFalse;

   724             }

   725         }

   726     return ETrue;

   727     }

   728 

   729 // ---------------------------------------------------------------------------

   730 // T_CLFApiModuleTests::CheckFileTypesL

   731 // ---------------------------------------------------------------------------

   732 //

   733 TBool T_CLFApiModuleTests::CheckFileTypesL( const MDesCArray& aMimeTypeArray,

   734                                             const TArray<TInt>& aMediaTypes )

   735     {

   736     for( TInt i = 0 ; i < iListModel->ItemCount() ; ++i )

   737         {

   738         TPtrC mimeType;

   739         TInt32 mediaType;

   740         TInt error = iListModel->Item( i ).GetField( ECLFFieldIdMimeType, mimeType );

   741         if( iListModel->Item( i ).GetField( ECLFFieldIdMediaType, mediaType ) != KErrNone )

   742             {

   743             return EFalse;

   744             }

   745         TBool mimeTypeVal( EFalse );

   746         TBool mediaTypeVal( EFalse );

   747         if( error == KErrNone )

   748             {

   749             mimeTypeVal = CheckMimeTypesL( aMimeTypeArray, mimeType );

   750             }

   751         mediaTypeVal = CheckMediaTypesL( aMediaTypes, TCLFMediaType( mediaType ) );

   752         if( !( mimeTypeVal || mediaTypeVal ) )

   753             {

   754             return EFalse;

   755             }

   756         }

   757     return ETrue;

   758     }

   759 

   760 // ---------------------------------------------------------------------------

   761 // T_CLFApiModuleTests::CheckMimeTypesL

   762 // ---------------------------------------------------------------------------

   763 //

   764 TBool T_CLFApiModuleTests::CheckMimeTypesL( const MDesCArray& aMimeTypeArray,

   765                                             const TDesC& aMimeType )

   766     {

   767     for( TInt j = 0 ; j < aMimeTypeArray.MdcaCount() ; ++j )

   768         {

   769         if( aMimeTypeArray.MdcaPoint( j ).Match( aMimeType ) == KErrNotFound )

   770             {

   771             return ETrue;

   772             }

   773         }

   774     return EFalse;

   775     }

   776 

   777 // ---------------------------------------------------------------------------

   778 // T_CLFApiModuleTests::CheckMediaTypesL

   779 // ---------------------------------------------------------------------------

   780 //

   781 TBool T_CLFApiModuleTests::CheckMediaTypesL( const TArray<TInt>& aMediaTypes,

   782                                              TCLFMediaType aMediaType )

   783     {

   784     for( TInt j = 0 ; j < aMediaTypes.Count() ; ++j )

   785         {

   786         if( aMediaTypes[j] == aMediaType )

   787             {

   788             return ETrue;

   789             }

   790         }

   791     return EFalse;

   792     }

   793 

   794 // ---------------------------------------------------------------------------

   795 // T_CLFApiModuleTests::MakeOpaqueDataL

   796 // ---------------------------------------------------------------------------

   797 //

   798 HBufC8* T_CLFApiModuleTests::MakeOpaqueDataL( const MDesCArray& aFiles )

   799     {

   800     CDesCArray* folderArray = new ( ELeave ) CDesCArraySeg( 8 );

   801     CleanupStack::PushL( folderArray );

   802     TInt count( aFiles.MdcaCount() );

   803     for( TInt i = 0 ; i < count ; ++i )

   804         {

   805         TPtrC folderPath( TParsePtrC(

   806                             aFiles.MdcaPoint( i ) ).DriveAndPath() );

   807         TInt tmp( 0 );

   808         if( folderArray->Find( folderPath, tmp, ECmpFolded ) != 0 )

   809             {

   810             folderArray->AppendL( folderPath );

   811             }

   812         }

   813 

   814     CBufBase* dynBuffer = CBufFlat::NewL( 64 );

   815     CleanupStack::PushL( dynBuffer );

   816     SerializeL( *folderArray, *dynBuffer );

   817     HBufC8* ret = dynBuffer->Ptr( 0 ).AllocL();

   818     CleanupStack::PopAndDestroy( 2, folderArray );

   819     return ret;

   820     }

   821 

   822 // ---------------------------------------------------------------------------

   823 // T_CLFApiModuleTests::MakeMultibleSortingItemsL

   824 // ---------------------------------------------------------------------------

   825 //

   826 void T_CLFApiModuleTests::MakeMultibleSortingItemsL(

   827                         RPointerArray<MCLFModifiableItem>& aItemArray )

   828     {

   829     for( TInt i = 0 ; i < 18 ; ++i )

   830         {

   831         MCLFModifiableItem* item = ContentListingFactory::NewModifiableItemLC();

   832         aItemArray.AppendL( item );

   833         CleanupStack::Pop();

   834 

   835         if( i < 3 )

   836             {

   837             item->AddFieldL( KMultibleSortingTestField1, i );

   838             }

   839         else if( i < 6 )

   840             {

   841             item->AddFieldL( KMultibleSortingTestField2, i );

   842             }

   843         else if( i < 9 )

   844             {

   845             item->AddFieldL( KMultibleSortingTestField3, i );

   846             }

   847         else if( i < 12 )

   848             {

   849             item->AddFieldL( KMultibleSortingTestField4, i );

   850             }

   851         else if( i < 15 )

   852             {

   853             item->AddFieldL( KMultibleSortingTestField5, i );

   854             }

   855         else

   856             {

   857             item->AddFieldL( KMultibleSortingTestField6, i );

   858             }

   859         }

   860     }

   861 

   862 // ---------------------------------------------------------------------------

   863 // T_CLFApiModuleTests::FindItem

   864 // ---------------------------------------------------------------------------

   865 //

   866 const MCLFItem* T_CLFApiModuleTests::FindItem( MCLFItemListModel& aModel, TCLFItemId aItemId )

   867     {

   868     for( TInt i = 0 ; i < aModel.ItemCount() ; ++i )

   869         {

   870         const MCLFItem& item = aModel.Item( i );

   871         if( item.ItemId() == aItemId )

   872             {

   873             return &item;

   874             }

   875         }

   876     return NULL;

   877     }

   878 

   879 /**

   880  * Setup

   881  */

   882 

   883 // ---------------------------------------------------------------------------

   884 // T_CLFApiModuleTests::BaseSetupL

   885 // ---------------------------------------------------------------------------

   886 // 

   887 void T_CLFApiModuleTests::BaseSetupL()

   888     {

   889     iFs.Close();

   890     iResourceFile.Close();

   891     

   892     User::LeaveIfError( iFs.Connect() );

   893     TFileName fileName( KTestResourceFile );

   894     BaflUtils::NearestLanguageFile( iFs, fileName );

   895     iResourceFile.OpenL( iFs, KTestResourceFile );

   896     iResourceFile.ConfirmSignatureL( 0 );

   897     }

   898 

   899 // ---------------------------------------------------------------------------

   900 // T_CLFApiModuleTests::SortingStyleResourceSetupL

   901 // ---------------------------------------------------------------------------

   902 // 

   903 void T_CLFApiModuleTests::SortingStyleResourceSetupL()

   904     {

   905     BaseSetupL();

   906     SortingStyleResourceL();

   907     }

   908 

   909 // ---------------------------------------------------------------------------

   910 // T_CLFApiModuleTests::CreateModelSetupL

   911 // ---------------------------------------------------------------------------

   912 // 

   913 void T_CLFApiModuleTests::CreateModelSetupL()

   914     {

   915     iEngine = ContentListingFactory::NewContentListingEngineLC();

   916     CleanupStack::Pop();

   917     iTestObserver  = new (ELeave) TTestOperationObserver;

   918     }

   919 

   920 // ---------------------------------------------------------------------------

   921 // T_CLFApiModuleTests::CreateModelFromResourceSetupL

   922 // ---------------------------------------------------------------------------

   923 // 

   924 void T_CLFApiModuleTests::CreateModelFromResourceSetupL()

   925     {

   926     BaseSetupL();

   927     CreateModelSetupL();

   928     ListModelResourceL();

   929     }

   930 

   931 // ---------------------------------------------------------------------------

   932 // T_CLFApiModuleTests::ListModelSetupL

   933 // ---------------------------------------------------------------------------

   934 // 

   935 void T_CLFApiModuleTests::ListModelSetupL()

   936     {

   937     BaseSetupL();

   938     CreateModelSetupL();

   939     iListModel = iEngine->CreateListModelLC( *iTestObserver );

   940     CleanupStack::Pop();

   941 

   942     iSortingStyle = ContentListingFactory::NewSortingStyleLC();

   943     CleanupStack::Pop();

   944     iSortingStyle1 = ContentListingFactory::NewSortingStyleLC();

   945     CleanupStack::Pop();

   946     iSortingStyle2 = ContentListingFactory::NewSortingStyleLC();

   947     CleanupStack::Pop();

   948     iSortingStyle3 = ContentListingFactory::NewSortingStyleLC();

   949     CleanupStack::Pop();

   950 

   951     iTestSorter = new (ELeave) TTestCustomSorter;

   952     iTestSorter1 = new (ELeave) TTestCustomSorter;

   953     iTestGrouper = new (ELeave) TTestCustomGrouper;

   954     iTestGrouper1 = new (ELeave) TTestCustomGrouper;

   955     iTestFilter = new (ELeave) TTestPostFilter;

   956     iTestFilter1 = new (ELeave) TTestPostFilter;

   957     iMimeTypeArray = new (ELeave) CDesCArrayFlat( 8 );

   958     iMimeTypeArray1 = new (ELeave) CDesCArrayFlat( 8 );

   959     }

   960 

   961 // ---------------------------------------------------------------------------

   962 // T_CLFApiModuleTests::MultibleSortingSetupL

   963 // ---------------------------------------------------------------------------

   964 // 

   965 void T_CLFApiModuleTests::MultibleSortingSetupL()

   966     {

   967     ListModelSetupL();

   968     MakeMultibleSortingItemsL( iModifiableItems );

   969 

   970 // use custom grouper to make own items

   971     iTestGrouper->iModifiableItems = &iModifiableItems;

   972     iTestGrouper->iCopyItems = ETrue;

   973     iListModel->SetCustomGrouper( iTestGrouper );

   974 

   975 // set sorters

   976     iSortingStyle->ResetL();

   977     iSortingStyle->SetSortingDataType( ECLFItemDataTypeTInt32 );

   978     iSortingStyle->AddFieldL( KMultibleSortingTestField1 );

   979     iSortingStyle->SetUndefinedItemPosition( ECLFSortingStyleUndefinedFirst );

   980 

   981     iSortingStyle1->ResetL();

   982     iSortingStyle1->SetSortingDataType( ECLFItemDataTypeTInt32 );

   983     iSortingStyle1->AddFieldL( KMultibleSortingTestField2 );

   984     iSortingStyle1->SetUndefinedItemPosition( ECLFSortingStyleUndefinedEnd );

   985     iSortingStyle1->SetOrdering( ECLFOrderingDescending );

   986 

   987     iSortingStyle2->ResetL();

   988     iSortingStyle2->SetSortingDataType( ECLFItemDataTypeTInt32 );

   989     iSortingStyle2->AddFieldL( KMultibleSortingTestField3 );

   990     iSortingStyle2->AddFieldL( KMultibleSortingTestField4 );

   991     iSortingStyle2->SetUndefinedItemPosition( ECLFSortingStyleUndefinedEnd );

   992 

   993     iSortingStyle3->ResetL();

   994     iSortingStyle3->SetSortingDataType( ECLFItemDataTypeTInt32 );

   995     iSortingStyle3->AddFieldL( KMultibleSortingTestField5 );

   996     iSortingStyle3->SetUndefinedItemPosition( ECLFSortingStyleUndefinedFirst );

   997 

   998     iListModel->SetSortingStyle( iSortingStyle );

   999     iListModel->AppendSecondarySortingStyleL( *iSortingStyle1 );

  1000     iListModel->AppendSecondarySortingStyleL( *iSortingStyle2 );

  1001     iListModel->AppendSecondarySortingStyleL( *iSortingStyle3 );

  1002     }

  1003 

  1004 // ---------------------------------------------------------------------------

  1005 // T_CLFApiModuleTests::MultibleSortingResourceSetupL

  1006 // ---------------------------------------------------------------------------

  1007 // 

  1008 void T_CLFApiModuleTests::MultibleSortingResourceSetupL()

  1009     {

  1010     ListModelSetupL();

  1011     delete iListModel;

  1012     iListModel = NULL;

  1013     ResourceL( R_LIST_MODEL_MULTIBLE );

  1014     iListModel = iEngine->CreateListModelLC( *iTestObserver, iResourceReader );

  1015     CleanupStack::Pop();

  1016 

  1017 // use custom grouper to make own items

  1018     MakeMultibleSortingItemsL( iModifiableItems );

  1019     iTestGrouper->iModifiableItems = &iModifiableItems;

  1020     iTestGrouper->iCopyItems = ETrue;

  1021     iListModel->SetCustomGrouper( iTestGrouper );

  1022 

  1023     }

  1024 

  1025 // ---------------------------------------------------------------------------

  1026 // T_CLFApiModuleTests::ListModelAllFileItemsSetupL

  1027 // ---------------------------------------------------------------------------

  1028 // 

  1029 void T_CLFApiModuleTests::ListModelAllFileItemsSetupL()

  1030     {

  1031     ListModelSetupL();

  1032     iMediaTypeArray.AppendL( ECLFMediaTypeVideo );

  1033     iMediaTypeArray.AppendL( ECLFMediaTypeImage );

  1034     iMediaTypeArray.AppendL( ECLFMediaTypeSound );

  1035     iMediaTypeArray.AppendL( ECLFMediaTypeMusic );

  1036     iMediaTypeArray.AppendL( ECLFMediaTypeStreamingURL );

  1037     iMediaTypeArray.AppendL( ECLFMediaTypePlaylist );

  1038     iListModel->SetWantedMediaTypesL( iMediaTypeArray.Array() );

  1039     iTestObserver->iWait = &iWait;

  1040     iListModel->RefreshL();

  1041     iWait.Start();

  1042     iItemCount = iListModel->ItemCount();

  1043     }

  1044 

  1045 // ---------------------------------------------------------------------------

  1046 // T_CLFApiModuleTests::ListModelSetupFromResourceL

  1047 // ---------------------------------------------------------------------------

  1048 // 

  1049 void T_CLFApiModuleTests::ListModelSetupFromResourceL()

  1050     {

  1051     BaseSetupL();

  1052     CreateModelSetupL();

  1053     ListModelResourceL();

  1054     iListModel = iEngine->CreateListModelLC( *iTestObserver, iResourceReader );

  1055     CleanupStack::Pop();

  1056     }

  1057 

  1058 // ---------------------------------------------------------------------------

  1059 // T_CLFApiModuleTests::EngineTestSetupL

  1060 // ---------------------------------------------------------------------------

  1061 // 

  1062 void T_CLFApiModuleTests::EngineTestSetupL()

  1063     {

  1064     User::LeaveIfError( iFs.Connect() );

  1065     iTestObserver  = new (ELeave) TTestOperationObserver;

  1066     iMimeTypeArray = new (ELeave) CDesCArrayFlat( 8 );

  1067     iEngine = ContentListingFactory::NewContentListingEngineLC();

  1068     CleanupStack::Pop();

  1069     iChangedItemObserver = new (ELeave) TTestChangedItemObserver;

  1070     iChangedItemObserver1 = new (ELeave) TTestChangedItemObserver;

  1071     iTestCLFProcessObserver = new (ELeave) TTestCLFProcessObserver;

  1072     iTestCLFProcessObserver1 = new (ELeave) TTestCLFProcessObserver;

  1073     }

  1074 

  1075 // ---------------------------------------------------------------------------

  1076 // T_CLFApiModuleTests::SortingStyleTestSetupL

  1077 // ---------------------------------------------------------------------------

  1078 // 

  1079 void T_CLFApiModuleTests::SortingStyleTestSetupL()

  1080     {

  1081     iSortingStyle = ContentListingFactory::NewSortingStyleLC();

  1082     CleanupStack::Pop();

  1083     }

  1084 

  1085 // ---------------------------------------------------------------------------

  1086 // T_CLFApiModuleTests::SortingStyleResourceTestSetupL

  1087 // ---------------------------------------------------------------------------

  1088 // 

  1089 void T_CLFApiModuleTests::SortingStyleResourceTestSetupL()

  1090     {

  1091     SortingStyleResourceSetupL();

  1092     iSortingStyle1 = ContentListingFactory::NewSortingStyleLC( iResourceReader );

  1093     CleanupStack::Pop();

  1094 

  1095     ResourceL( R_SORTING_STYLE_EMPTY );

  1096     iSortingStyle = ContentListingFactory::NewSortingStyleLC( iResourceReader );

  1097     CleanupStack::Pop();

  1098 

  1099     ResourceL( R_SORTING_STYLE_UNDEFINEDITEM );

  1100     iSortingStyle2 = ContentListingFactory::NewSortingStyleLC( iResourceReader );

  1101     CleanupStack::Pop();

  1102     }

  1103 

  1104 // ---------------------------------------------------------------------------

  1105 // T_CLFApiModuleTests::ModifiableItemTestSetupL

  1106 // ---------------------------------------------------------------------------

  1107 // 

  1108 void T_CLFApiModuleTests::ModifiableItemTestSetupL()

  1109     {

  1110     iModifiableItem = ContentListingFactory::NewModifiableItemLC();

  1111     CleanupStack::Pop();

  1112     }

  1113 

  1114 // ---------------------------------------------------------------------------

  1115 // T_CLFApiModuleTests::ItemTestSetupL

  1116 // ---------------------------------------------------------------------------

  1117 // 

  1118 void T_CLFApiModuleTests::ItemTestSetupL()

  1119     {

  1120     ListModelSetupL();

  1121     CreateNewFileL( 12, iFileName );

  1122     iEngine->UpdateItemsL();

  1123     iMimeTypeArray->Reset();

  1124     iMimeTypeArray->AppendL( _L("*") );

  1125     iListModel->SetWantedMimeTypesL( *iMimeTypeArray );

  1126 

  1127     iTestObserver->iWait = &iWait;

  1128     iListModel->RefreshL();

  1129     iWait.Start();

  1130 

  1131     for( TInt i = 0 ; i < iListModel->ItemCount() ; ++i )

  1132         {

  1133         const MCLFItem& item = iListModel->Item( i );

  1134         TPtrC fn;