1 /*

     2 * Copyright (c) 2008-2009 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 // [INCLUDE FILES] - do not remove

    19 #include <e32svr.h>

    20 #include <s32mem.h>

    21 #include <ecom.h>

    22 #include <StifParser.h>

    23 #include <StifTestEventInterface.h>

    24 #include <Stiftestinterface.h>

    25 #include "ContentListingFrameworkTest.h"

    26 

    27 // the header for the tested class

    28 #include <ContentListingFactory.h>

    29 #include <MCLFChangedItemObserver.h>

    30 #include <MCLFContentListingEngine.h>

    31 #include <MCLFCustomGrouper.h>

    32 #include <MCLFCustomSorter.h>

    33 #include <MCLFItem.h>

    34 #include <MCLFItemListModel.h>

    35 #include <MCLFModifiableItem.h>

    36 #include <MCLFOperationObserver.h>

    37 #include <MCLFPostFilter.h>

    38 #include <MCLFSortingStyle.h>

    39 #include <ContentListingFrameworkTest.rsg>

    40 #include <collate.h>

    41 #include <pathInfo.h>

    42 #include <MCLFProcessObserver.h>

    43 #include <CLFContentListingExtended.hrh>

    44 

    45 // CONSTANTS

    46 #ifdef __WINSCW__

    47 _LIT( KTestResourceFile, "z:\\resource\\ContentListingFrameworkTest.rsc" );

    48 #else

    49 _LIT( KTestResourceFile, "c:\\resource\\ContentListingFrameworkTest.rsc" );

    50 #endif

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

    52 _LIT( KTestFileExt, ".txt" );

    53 

    54 const TCLFFieldId KMultibleSortingTestField1 = 0x80000001;

    55 const TCLFFieldId KMultibleSortingTestField2 = 0x80000002;

    56 const TCLFFieldId KMultibleSortingTestField3 = 0x80000003;

    57 const TCLFFieldId KMultibleSortingTestField4 = 0x80000004;

    58 const TCLFFieldId KMultibleSortingTestField5 = 0x80000005;

    59 const TCLFFieldId KMultibleSortingTestField6 = 0x80000006;

    60 

    61 const TInt KCLFUpdateFoldersSemanticId = 0x1000;

    62 

    63 // ---------------------------------------------------------------------------

    64 // class CMGXAsyncCallback

    65 // ---------------------------------------------------------------------------

    66 //

    67 class CCLFAsyncCallback : public CBase

    68     {

    69     public:

    70         ~CCLFAsyncCallback()

    71             {

    72             if ( iActiveWait.IsStarted() )

    73                 {

    74                 iActiveWait.AsyncStop();

    75                 }

    76             }

    77     public:

    78         static void AfterL( TTimeIntervalMicroSeconds32 aInterval )

    79             {

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

    81             CleanupStack::PushL( self );

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

    83             CleanupStack::PushL( periodic );

    84             TCallBack callBack( CallBackL, self );

    85             TTimeIntervalMicroSeconds32 interval( 1000000 );

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

    87             self->iActiveWait.Start();

    88             periodic->Cancel();

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

    90             }

    91 

    92         static TInt CallBackL( TAny* aObject )

    93             {

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

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

    96                 {

    97                 self->iActiveWait.AsyncStop();

    98                 }

    99             return EFalse;

   100             }

   101             

   102     private:

   103         CActiveSchedulerWait iActiveWait;

   104     };

   105 

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

   107 // class TTestOperationObserver

   108 // ---------------------------------------------------------------------------

   109 //

   110 class TTestOperationObserver : public MCLFOperationObserver

   111     {

   112     public:

   113         TTestOperationObserver()

   114             // set invalid values

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

   116             {}

   117         void HandleOperationEventL( TCLFOperationEvent aOperationEvent,

   118                                     TInt aError )

   119             {

   120             iError = aError;

   121             iOperationEvent = aOperationEvent;

   122             if( iWait &&

   123                 iWait->IsStarted() )

   124                 {

   125                 iWait->AsyncStop();

   126                 }

   127             }

   128         TCLFOperationEvent iOperationEvent;

   129         TInt iError;

   130         CActiveSchedulerWait* iWait;

   131 

   132     };

   133 

   134 // ---------------------------------------------------------------------------

   135 // class TTestCustomSorter

   136 // ---------------------------------------------------------------------------

   137 //

   138 class TTestCustomSorter : public MCLFCustomSorter

   139     {

   140     public:

   141         TTestCustomSorter() : iSortItems( EFalse )

   142             {

   143             }

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

   145             {

   146             //aItemArray;

   147             iSortItems = ETrue;

   148             }

   149         TBool iSortItems;

   150 

   151     };

   152 

   153 // ---------------------------------------------------------------------------

   154 // class TTestCustomGrouper

   155 // ---------------------------------------------------------------------------

   156 //

   157 class TTestCustomGrouper : public MCLFCustomGrouper

   158     {

   159     public:

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

   161             {

   162             }

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

   164                           RPointerArray<MCLFItem>& aGroupedList )

   165             {

   166             //aSourceList;

   167             if( iCopyItems )

   168                 {

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

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

   171                     {

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

   173                     }

   174                 }

   175             else if( iModifiableItems )

   176                 {

   177                 iModifiableItems->ResetAndDestroy();

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

   179                     {

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

   181                     iModifiableItems->AppendL( item );

   182                     CleanupStack::Pop(); // item

   183                     aGroupedList.AppendL( item );

   184                     }

   185                 }

   186             }

   187         TInt iGroupCount;

   188         TBool iCopyItems;

   189         RPointerArray<MCLFModifiableItem>* iModifiableItems;

   190     };

   191 

   192 // ---------------------------------------------------------------------------

   193 // class TTestPostFilter

   194 // ---------------------------------------------------------------------------

   195 //

   196 class TTestPostFilter : public MCLFPostFilter

   197     {

   198     public:

   199         TTestPostFilter() : iShouldFilterCount( 5 ), iAllFilter( EFalse ), iFilteredCount( 0 )

   200             {

   201             }

   202 

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

   204                            RPointerArray<MCLFItem>& aFilteredItemList )

   205             {

   206             iFilteredCount = 0;

   207             if( iAllFilter )

   208                 {

   209                 iFilteredCount = aItemList.Count();

   210                 return;

   211                 }

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

   213                 {

   214                 if( i < iShouldFilterCount  )

   215                     {

   216                     iFilteredCount++;

   217                     }

   218                 else

   219                     {

   220                     aFilteredItemList.AppendL( aItemList[i] );

   221                     }

   222                 }

   223             }

   224         TInt iShouldFilterCount;

   225         TBool iAllFilter;

   226         TInt iFilteredCount;

   227 

   228     };

   229 

   230 // ---------------------------------------------------------------------------

   231 // class TTestChangedItemObserver

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

   233 //

   234 class TTestChangedItemObserver : public MCLFChangedItemObserver

   235     {

   236     public:

   237         TTestChangedItemObserver()

   238             : iHandleItemChange( EFalse ),

   239               iLastError( KErrNone ),

   240               iChangedArray( NULL ),

   241               iWait( NULL )      

   242             {

   243             }

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

   245             {

   246             iHandleItemChange = ETrue;

   247             if( iChangedArray )

   248                 {

   249                 iChangedArray->Reset();

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

   251                     {

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

   253                     }

   254                 }

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

   256                 {

   257                 iWait->AsyncStop();

   258                 }

   259 

   260             }

   261         void HandleError( TInt aError )

   262             {

   263             iLastError = aError;

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

   265                 {

   266                 iWait->AsyncStop();

   267                 }

   268             }

   269         TInt iHandleItemChange;

   270         TInt iLastError;

   271         RArray<TCLFItemId>* iChangedArray;

   272         CActiveSchedulerWait* iWait;

   273     };

   274 

   275 // ---------------------------------------------------------------------------

   276 // class TTestCLFProcessObserver

   277 // ---------------------------------------------------------------------------

   278 //

   279 class TTestCLFProcessObserver : public MCLFProcessObserver

   280     {

   281     public:

   282         TTestCLFProcessObserver()

   283             : iStartEvent( EFalse ), iEndEvent( EFalse )

   284             {}

   285         void HandleCLFProcessEventL( TCLFProcessEvent aProcessEvent )

   286             {

   287             switch ( aProcessEvent )

   288                 {

   289                 case ECLFUpdateStart:

   290                     {

   291                     iStartEvent = ETrue;

   292                     break;

   293                     }

   294                 case ECLFUpdateStop:

   295                     {

   296                     iEndEvent = ETrue;

   297                     break;

   298                     }

   299                 default:

   300                     {

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

   302                     }

   303                 }

   304             }

   305         void Reset()

   306             {

   307             iStartEvent = EFalse;

   308             iEndEvent = EFalse;

   309             }

   310         TBool iStartEvent;

   311         TBool iEndEvent;

   312     };

   313 

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

   315     {

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

   317     RBufWriteStream writeStream( aBuffer );

   318     CleanupClosePushL( writeStream );

   319     writeStream.WriteInt32L( count );

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

   321         {

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

   323         TInt length( des.Length() );

   324         writeStream.WriteInt32L( length );

   325         writeStream.WriteL( des, length );

   326         }

   327     CleanupStack::PopAndDestroy( &writeStream );

   328     }

   329 

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

   331 

   332 // -----------------------------------------------------------------------------

   333 // CContentListingFrameworkTest::Delete

   334 // Delete here all resources allocated and opened from test methods. 

   335 // Called from destructor. 

   336 // -----------------------------------------------------------------------------

   337 //

   338 void CContentListingFrameworkTest::Delete() 

   339     {

   340     }

   341 

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

   343 // CCollectionManagerTest::RunMethodL

   344 // Run specified method. Contains also table of test mothods and their names.

   345 // -----------------------------------------------------------------------------

   346 //

   347 TInt CContentListingFrameworkTest::RunMethodL( 

   348     CStifItemParser& aItem ) 

   349     {

   350 

   351     static TStifFunctionInfo const KFunctions[] =

   352         {  

   353         // Copy this line for every implemented function.

   354         // First string is the function name used in TestScripter script file.

   355         // Second is the actual implementation member function. 

   356 

   357         // engine		

   358         ENTRY( "BaseSetup", CContentListingFrameworkTest::BaseSetupL ),

   359         ENTRY( "SortingStyleResourceSetup", CContentListingFrameworkTest::SortingStyleResourceSetupL ),

   360         ENTRY( "CreateModelSetup", CContentListingFrameworkTest::CreateModelSetupL ),

   361         ENTRY( "CreateModelFromResourceSetup", CContentListingFrameworkTest::CreateModelFromResourceSetupL ),

   362         ENTRY( "ListModelSetup", CContentListingFrameworkTest::ListModelSetupL ),

   363         ENTRY( "ListModelSetupFromResource", CContentListingFrameworkTest::ListModelSetupFromResourceL ),

   364         ENTRY( "ListModelAllFileItemsSetup", CContentListingFrameworkTest::ListModelAllFileItemsSetupL ),

   365         ENTRY( "EngineTestSetup", CContentListingFrameworkTest::EngineTestSetupL ),

   366         ENTRY( "SortingStyleTestSetup", CContentListingFrameworkTest::SortingStyleTestSetupL ),

   367         ENTRY( "SortingStyleResourceTestSetup", CContentListingFrameworkTest::SortingStyleResourceTestSetupL ),

   368         ENTRY( "ModifiableItemTestSetup", CContentListingFrameworkTest::ModifiableItemTestSetupL ),

   369         ENTRY( "ItemTestSetup", CContentListingFrameworkTest::ItemTestSetupL ),

   370         ENTRY( "MultibleSortingSetup", CContentListingFrameworkTest::MultibleSortingSetupL ),

   371         ENTRY( "MultibleSortingResourceSetup", CContentListingFrameworkTest::MultibleSortingResourceSetupL ),

   372         ENTRY( "Teardown", CContentListingFrameworkTest::Teardown ),

   373         ENTRY( "CreateEngineTest", CContentListingFrameworkTest::CreateEngineTestL ),

   374         ENTRY( "CreateModifiableItemTest", CContentListingFrameworkTest::CreateModifiableItemTestL ),

   375         ENTRY( "CreateSortignStyleTest", CContentListingFrameworkTest::CreateSortignStyleTestL ),

   376         ENTRY( "CreateSortignStyleFromResourceTest", CContentListingFrameworkTest::CreateSortignStyleFromResourceTestL ),

   377         ENTRY( "CreateListModelTest", CContentListingFrameworkTest::CreateListModelTestL ),

   378         ENTRY( "CreateListModelFromResourceTest", CContentListingFrameworkTest::CreateListModelFromResourceTestL ),

   379         ENTRY( "UpdateItemsTest", CContentListingFrameworkTest::UpdateItemsTestL ),

   380         ENTRY( "UpdateItemsWithIdTest", CContentListingFrameworkTest::UpdateItemsWithIdTestL ),

   381         ENTRY( "UpdateItemsWithOpaqueDataFolderTest", CContentListingFrameworkTest::UpdateItemsWithOpaqueDataFolderTestL ),

   382         ENTRY( "SortingStyleResourceTest", CContentListingFrameworkTest::SortingStyleResourceTestL ),

   383         ENTRY( "SortingStyleOrderingTest", CContentListingFrameworkTest::SortingStyleOrderingTestL ),

   384         ENTRY( "SortingStyleDataTypeTest", CContentListingFrameworkTest::SortingStyleDataTypeTestL ),

   385         ENTRY( "SortingStyleUndefinedItemPositionTest", CContentListingFrameworkTest::SortingStyleUndefinedItemPositionTestL ),

   386         ENTRY( "SortingStyleFieldTest", CContentListingFrameworkTest::SortingStyleFieldTestL ),

   387         ENTRY( "RefreshTest", CContentListingFrameworkTest::RefreshTestL ),

   388         ENTRY( "SetSortingStyleTest", CContentListingFrameworkTest::SetSortingStyleTestL ),

   389         ENTRY( "SetCustomSorterTest", CContentListingFrameworkTest::SetCustomSorterTestL ),

   390         ENTRY( "GroupingTest", CContentListingFrameworkTest::GroupingTestL ),

   391         ENTRY( "SetPostFilterTest", CContentListingFrameworkTest::SetPostFilterTestL ),

   392         ENTRY( "SetWantedMimeTypesTest", CContentListingFrameworkTest::SetWantedMimeTypesTestL ),

   393         ENTRY( "SetWantedMediaTypesTest", CContentListingFrameworkTest::SetWantedMediaTypesTestL ),

   394         ENTRY( "SetWantedMediaAndMimeTypesTest", CContentListingFrameworkTest::SetWantedMediaAndMimeTypesTestL ),

   395         ENTRY( "MultibleSortingTest", CContentListingFrameworkTest::MultibleSortingTestL ),

   396         ENTRY( "ModelItemsChangedTest", CContentListingFrameworkTest::ModelItemsChangedTestL ),

   397         ENTRY( "ItemFieldTest", CContentListingFrameworkTest::ItemFieldTestL ),

   398         ENTRY( "MIFieldTest", CContentListingFrameworkTest::MIFieldTestL ),

   399         };

   400     

   401     const TInt count = sizeof( KFunctions ) / 

   402                         sizeof( TStifFunctionInfo );

   403 

   404     return RunInternalL( KFunctions, count, aItem );

   405 

   406     }

   407 

   408 /**

   409  * Assistance methods

   410  */

   411 

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

   413 // CContentListingFrameworkTest::ResourceL

   414 // ---------------------------------------------------------------------------

   415 //

   416 void CContentListingFrameworkTest::ResourceL( TInt aResourceId )

   417     {

   418     delete iDataBuffer;

   419     iDataBuffer = NULL;

   420     iDataBuffer = iResourceFile.AllocReadL( aResourceId );

   421     iResourceReader.SetBuffer( iDataBuffer );

   422     }

   423 

   424 // ---------------------------------------------------------------------------

   425 // CContentListingFrameworkTest::SortingStyleResourceL

   426 // ---------------------------------------------------------------------------

   427 //

   428 void CContentListingFrameworkTest::SortingStyleResourceL()

   429     {

   430     ResourceL( R_SORTING_STYLE );

   431     }

   432 

   433 // ---------------------------------------------------------------------------

   434 // CContentListingFrameworkTest::ListModelResourceL

   435 // ---------------------------------------------------------------------------

   436 //

   437 void CContentListingFrameworkTest::ListModelResourceL()

   438     {

   439     ResourceL( R_LIST_MODEL );

   440     }

   441 

   442 // ---------------------------------------------------------------------------

   443 // CContentListingFrameworkTest::CreateNewFileL

   444 // ---------------------------------------------------------------------------

   445 //

   446 void CContentListingFrameworkTest::CreateNewFileL( TInt aNumber, TDes& aFileName )

   447     {

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

   449     aFileName.Append( KTestFileNameBase );

   450     TBuf<125> buf;

   451     buf.Num( aNumber );

   452     aFileName.Append( buf );

   453     aFileName.Append( KTestFileExt );

   454 

   455     RFile file;

   456     BaflUtils::EnsurePathExistsL( iFs, aFileName );

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

   458     if( error == KErrNone )

   459         {

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

   461         }

   462     file.Close();

   463     User::LeaveIfError( error );

   464     }

   465 

   466 // ---------------------------------------------------------------------------

   467 // CContentListingFrameworkTest::FindTestFileIdL

   468 // ---------------------------------------------------------------------------

   469 //

   470 TCLFItemId CContentListingFrameworkTest::FindTestFileIdL( TInt aNumber )

   471     {

   472     TCLFItemId id( 0 );

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

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

   475     

   476     iTestObserver->iWait = &iWait;

   477     model->SetWantedMimeTypesL( *iMimeTypeArray );

   478     model->RefreshL();

   479     iWait.Start();

   480 

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

   482     testFileName.Append( KTestFileNameBase );

   483     TBuf<125> buf;

   484     buf.Num( aNumber );

   485     testFileName.Append( buf );

   486     testFileName.Append( KTestFileExt );

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

   488         {

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

   490         TPtrC fileName;

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

   492             {

   493             continue;

   494             }

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

   496             {

   497             id = item.ItemId();

   498             break;

   499             }

   500         }

   501     CleanupStack::PopAndDestroy(); // model

   502     return id;

   503     }

   504 

   505 // ---------------------------------------------------------------------------

   506 // CContentListingFrameworkTest::CheckFileNameShortingL

   507 // ---------------------------------------------------------------------------

   508 //

   509 TBool CContentListingFrameworkTest::CheckFileNameShortingL()

   510     {

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

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

   513 

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

   515         {

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

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

   518         TPtrC name;

   519         TPtrC name1;

   520 

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

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

   523             {

   524             return EFalse;

   525             }

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

   527             {

   528             return EFalse;

   529             }

   530         }

   531     return ETrue;

   532     }

   533 

   534 // ---------------------------------------------------------------------------

   535 // CContentListingFrameworkTest::CheckFileSizeShortingL

   536 // ---------------------------------------------------------------------------

   537 //

   538 TBool CContentListingFrameworkTest::CheckFileSizeShortingL()

   539     {

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

   541         {

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

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

   544         TInt32 size;

   545         TInt32 size1;

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

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

   548             {

   549             return EFalse;

   550             }

   551         if( size < size1 )

   552             {

   553             return EFalse;

   554             }

   555         }

   556     return ETrue;

   557     }

   558 

   559 // ---------------------------------------------------------------------------

   560 // CContentListingFrameworkTest::CheckMultibleSortingShortingL

   561 // ---------------------------------------------------------------------------

   562 //

   563 TBool CContentListingFrameworkTest::CheckMultibleSortingShortingL()

   564     {

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

   566     TInt32 data( 0 );

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

   568         data != 5 )

   569         {

   570         return EFalse;

   571         }

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

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

   574         data != 4 )

   575         {

   576         return EFalse;

   577         }

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

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

   580         data != 3 )

   581         {

   582         return EFalse;

   583         }

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

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

   586         data != 6 )

   587         {

   588         return EFalse;

   589         }

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

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

   592         data != 7 )

   593         {

   594         return EFalse;

   595         }

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

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

   598         data != 8 )

   599         {

   600         return EFalse;

   601         }

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

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

   604         data != 9 )

   605         {

   606         return EFalse;

   607         }

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

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

   610         data != 10 )

   611         {

   612         return EFalse;

   613         }

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

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

   616         data != 11 )

   617         {

   618         return EFalse;

   619         }

   620 // unsorted start

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

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

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

   624         {

   625         return EFalse;

   626         }

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

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

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

   630         {

   631         return EFalse;

   632         }

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

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

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

   636         {

   637         return EFalse;

   638         }

   639 // unsorted end

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

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

   642         data != 12 )

   643         {

   644         return EFalse;

   645         }

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

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

   648         data != 13 )

   649         {

   650         return EFalse;

   651         }

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

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

   654         data != 14 )

   655         {

   656         return EFalse;

   657         }

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

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

   660         data != 0 )

   661         {

   662         return EFalse;

   663         }

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

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

   666         data != 1 )

   667         {

   668         return EFalse;

   669         }

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

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

   672         data != 2 )

   673         {

   674         return EFalse;

   675         }

   676 

   677     return ETrue;

   678     }

   679 

   680 // ---------------------------------------------------------------------------

   681 // CContentListingFrameworkTest::CheckMultibleSortingShorting2L

   682 // ---------------------------------------------------------------------------

   683 //

   684 TBool CContentListingFrameworkTest::CheckMultibleSortingShorting2L()

   685     {

   686 // check sorted

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

   688     TInt32 data( 0 );

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

   690         data != 12 )

   691         {

   692         return EFalse;

   693         }

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

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

   696         data != 13 )

   697         {

   698         return EFalse;

   699         }

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

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

   702         data != 14 )

   703         {

   704         return EFalse;

   705         }

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

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

   708         data != 15 )

   709         {

   710         return EFalse;

   711         }

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

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

   714         data != 16 )

   715         {

   716         return EFalse;

   717         }

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

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

   720         data != 17 )

   721         {

   722         return EFalse;

   723         }

   724 // check unsorted

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

   726         {

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

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

   729             {

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

   731                 {

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

   733                     {

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

   735                         {

   736                         return EFalse;

   737                         }

   738                     }

   739                 }

   740             }

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

   742             {

   743             return EFalse;

   744             }

   745         }

   746 

   747     return ETrue;

   748     }

   749 

   750 // ---------------------------------------------------------------------------

   751 // CContentListingFrameworkTest::CheckFileDateShortingL

   752 // ---------------------------------------------------------------------------

   753 //

   754 TBool CContentListingFrameworkTest::CheckFileDateShortingL()

   755     {

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

   757         {

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

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

   760         TTime date;

   761         TTime date1;

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

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

   764             {

   765             return EFalse;

   766             }

   767         if( date > date1 )

   768             {

   769             return EFalse;

   770             }

   771         }

   772     return ETrue;

   773     }

   774 

   775 // ---------------------------------------------------------------------------

   776 // CContentListingFrameworkTest::CheckFileTypesL

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

   778 //

   779 TBool CContentListingFrameworkTest::CheckFileTypesL( const MDesCArray& aMimeTypeArray,

   780                                             const TArray<TInt>& aMediaTypes )

   781     {

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

   783         {

   784         TPtrC mimeType;

   785         TInt32 mediaType;

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

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

   788             {

   789             return EFalse;

   790             }

   791         TBool mimeTypeVal( EFalse );

   792         TBool mediaTypeVal( EFalse );

   793         if( error == KErrNone )

   794             {

   795             mimeTypeVal = CheckMimeTypesL( aMimeTypeArray, mimeType );

   796             }

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

   798         if( !( mimeTypeVal || mediaTypeVal ) )

   799             {

   800             return EFalse;

   801             }

   802         }

   803     return ETrue;

   804     }

   805 

   806 // ---------------------------------------------------------------------------

   807 // CContentListingFrameworkTest::CheckMimeTypesL

   808 // ---------------------------------------------------------------------------

   809 //

   810 TBool CContentListingFrameworkTest::CheckMimeTypesL( const MDesCArray& aMimeTypeArray,

   811                                             const TDesC& aMimeType )

   812     {

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

   814         {

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

   816             {

   817             return ETrue;

   818             }

   819         }

   820     return EFalse;

   821     }

   822 

   823 // ---------------------------------------------------------------------------

   824 // CContentListingFrameworkTest::CheckMediaTypesL

   825 // ---------------------------------------------------------------------------

   826 //

   827 TBool CContentListingFrameworkTest::CheckMediaTypesL( const TArray<TInt>& aMediaTypes,

   828                                              TCLFMediaType aMediaType )

   829     {

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

   831         {

   832         if( aMediaTypes[j] == aMediaType )

   833             {

   834             return ETrue;

   835             }

   836         }

   837     return EFalse;

   838     }

   839 

   840 // ---------------------------------------------------------------------------

   841 // CContentListingFrameworkTest::MakeOpaqueDataL

   842 // ---------------------------------------------------------------------------

   843 //

   844 HBufC8* CContentListingFrameworkTest::MakeOpaqueDataL( const MDesCArray& aFiles )

   845     {

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

   847     CleanupStack::PushL( folderArray );

   848     TInt count( aFiles.MdcaCount() );

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

   850         {

   851         TPtrC folderPath( TParsePtrC(

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

   853         TInt tmp( 0 );

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

   855             {

   856             folderArray->AppendL( folderPath );

   857             }

   858         }

   859 

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

   861     CleanupStack::PushL( dynBuffer );

   862     SerializeL( *folderArray, *dynBuffer );

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

   864     CleanupStack::PopAndDestroy( 2, folderArray );

   865     return ret;

   866     }

   867 

   868 // ---------------------------------------------------------------------------

   869 // CContentListingFrameworkTest::MakeMultibleSortingItemsL

   870 // ---------------------------------------------------------------------------

   871 //

   872 void CContentListingFrameworkTest::MakeMultibleSortingItemsL(

   873                         RPointerArray<MCLFModifiableItem>& aItemArray )

   874     {

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

   876         {

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

   878         aItemArray.AppendL( item );

   879         CleanupStack::Pop(); //item

   880 

   881         if( i < 3 )

   882             {

   883             item->AddFieldL( KMultibleSortingTestField1, i );

   884             }

   885         else if( i < 6 )

   886             {

   887             item->AddFieldL( KMultibleSortingTestField2, i );

   888             }

   889         else if( i < 9 )

   890             {

   891             item->AddFieldL( KMultibleSortingTestField3, i );

   892             }

   893         else if( i < 12 )

   894             {

   895             item->AddFieldL( KMultibleSortingTestField4, i );

   896             }

   897         else if( i < 15 )

   898             {

   899             item->AddFieldL( KMultibleSortingTestField5, i );

   900             }

   901         else

   902             {

   903             item->AddFieldL( KMultibleSortingTestField6, i );

   904             }

   905         }

   906     }

   907 

   908 // ---------------------------------------------------------------------------

   909 // CContentListingFrameworkTest::FindItem

   910 // ---------------------------------------------------------------------------

   911 //

   912 const MCLFItem* CContentListingFrameworkTest::FindItem( MCLFItemListModel& aModel, TCLFItemId aItemId )

   913     {

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

   915         {

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

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

   918             {

   919             return &item;

   920             }

   921         }

   922     return NULL;

   923     }

   924 

   925 /**

   926  * Setup

   927  */

   928 

   929 // ---------------------------------------------------------------------------

   930 // CContentListingFrameworkTest::BaseSetupL

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

   932 // 

   933 TInt CContentListingFrameworkTest::BaseSetupL( CStifItemParser& /* aItem */ )

   934     {

   935     iFs.Close();

   936     iResourceFile.Close();

   937     

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

   939     TFileName fileName( KTestResourceFile );

   940     BaflUtils::NearestLanguageFile( iFs, fileName );

   941     iResourceFile.OpenL( iFs, KTestResourceFile );

   942     iResourceFile.ConfirmSignatureL( 0 );

   943 

   944     return KErrNone;

   945     }

   946 

   947 // ---------------------------------------------------------------------------

   948 // CContentListingFrameworkTest::SortingStyleResourceSetupL

   949 // ---------------------------------------------------------------------------

   950 // 

   951 TInt CContentListingFrameworkTest::SortingStyleResourceSetupL( CStifItemParser& aItem )

   952     {

   953     BaseSetupL( aItem );

   954     SortingStyleResourceL();

   955 

   956     return KErrNone;

   957     }

   958 

   959 // ---------------------------------------------------------------------------

   960 // CContentListingFrameworkTest::CreateModelSetupL

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

   962 // 

   963 TInt CContentListingFrameworkTest::CreateModelSetupL( CStifItemParser& /* aItem */ )

   964     {

   965     iEngine = ContentListingFactory::NewContentListingEngineLC();

   966     CleanupStack::Pop(); //engine

   967     iTestObserver  = new (ELeave) TTestOperationObserver;

   968     return KErrNone;

   969     }

   970 

   971 // ---------------------------------------------------------------------------

   972 // CContentListingFrameworkTest::CreateModelFromResourceSetupL

   973 // ---------------------------------------------------------------------------

   974 // 

   975 TInt CContentListingFrameworkTest::CreateModelFromResourceSetupL( CStifItemParser& aItem )

   976     {

   977     BaseSetupL( aItem );

   978     CreateModelSetupL( aItem );

   979     ListModelResourceL();

   980 

   981     return KErrNone;

   982     }

   983 

   984 // ---------------------------------------------------------------------------

   985 // CContentListingFrameworkTest::ListModelSetupL

   986 // ---------------------------------------------------------------------------

   987 // 

   988 TInt CContentListingFrameworkTest::ListModelSetupL( CStifItemParser& aItem )

   989     {

   990     BaseSetupL( aItem );

   991     CreateModelSetupL( aItem );

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

   993     CleanupStack::Pop(); //listModel

   994 

   995     iSortingStyle = ContentListingFactory::NewSortingStyleLC();

   996     CleanupStack::Pop(); // sortingStyle

   997     iSortingStyle1 = ContentListingFactory::NewSortingStyleLC();

   998     CleanupStack::Pop(); // sortingStyle

   999     iSortingStyle2 = ContentListingFactory::NewSortingStyleLC();

  1000     CleanupStack::Pop(); // sortingStyle

  1001     iSortingStyle3 = ContentListingFactory::NewSortingStyleLC();

  1002     CleanupStack::Pop(); // sortingStyle

  1003 

  1004     iTestSorter = new (ELeave) TTestCustomSorter;

  1005     iTestSorter1 = new (ELeave) TTestCustomSorter;

  1006     iTestGrouper = new (ELeave) TTestCustomGrouper;

  1007     iTestGrouper1 = new (ELeave) TTestCustomGrouper;

  1008     iTestFilter = new (ELeave) TTestPostFilter;

  1009     iTestFilter1 = new (ELeave) TTestPostFilter;

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

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

  1012     

  1013     return KErrNone;

  1014     }

  1015 

  1016 // ---------------------------------------------------------------------------

  1017 // CContentListingFrameworkTest::MultibleSortingSetupL

  1018 // ---------------------------------------------------------------------------

  1019 // 

  1020 TInt CContentListingFrameworkTest::MultibleSortingSetupL( CStifItemParser& aItem )

  1021     {

  1022     ListModelSetupL( aItem );

  1023     MakeMultibleSortingItemsL( iModifiableItems );

  1024 

  1025 // use custom grouper to make own items

  1026     iTestGrouper->iModifiableItems = &iModifiableItems;

  1027     iTestGrouper->iCopyItems = ETrue;

  1028     iListModel->SetCustomGrouper( iTestGrouper );

  1029 

  1030 // set sorters

  1031     iSortingStyle->ResetL();

  1032     iSortingStyle->SetSortingDataType( ECLFItemDataTypeTInt32 );

  1033     iSortingStyle->AddFieldL( KMultibleSortingTestField1 );

  1034     iSortingStyle->SetUndefinedItemPosition( ECLFSortingStyleUndefinedFirst );

  1035 

  1036     iSortingStyle1->ResetL();

  1037     iSortingStyle1->SetSortingDataType( ECLFItemDataTypeTInt32 );

  1038     iSortingStyle1->AddFieldL( KMultibleSortingTestField2 );

  1039     iSortingStyle1->SetUndefinedItemPosition( ECLFSortingStyleUndefinedEnd );

  1040     iSortingStyle1->SetOrdering( ECLFOrderingDescending );

  1041 

  1042     iSortingStyle2->ResetL();

  1043     iSortingStyle2->SetSortingDataType( ECLFItemDataTypeTInt32 );

  1044     iSortingStyle2->AddFieldL( KMultibleSortingTestField3 );

  1045     iSortingStyle2->AddFieldL( KMultibleSortingTestField4 );

  1046     iSortingStyle2->SetUndefinedItemPosition( ECLFSortingStyleUndefinedEnd );

  1047 

  1048     iSortingStyle3->ResetL();

  1049     iSortingStyle3->SetSortingDataType( ECLFItemDataTypeTInt32 );

  1050     iSortingStyle3->AddFieldL( KMultibleSortingTestField5 );

  1051     iSortingStyle3->SetUndefinedItemPosition( ECLFSortingStyleUndefinedFirst );

  1052 

  1053     iListModel->SetSortingStyle( iSortingStyle );

  1054     iListModel->AppendSecondarySortingStyleL( *iSortingStyle1 );

  1055     iListModel->AppendSecondarySortingStyleL( *iSortingStyle2 );

  1056     iListModel->AppendSecondarySortingStyleL( *iSortingStyle3 );

  1057 

  1058     return KErrNone;

  1059     }

  1060 

  1061 // ---------------------------------------------------------------------------

  1062 // CContentListingFrameworkTest::MultibleSortingResourceSetupL

  1063 // ---------------------------------------------------------------------------

  1064 // 

  1065 TInt CContentListingFrameworkTest::MultibleSortingResourceSetupL( CStifItemParser& aItem )

  1066     {

  1067     ListModelSetupL( aItem );

  1068     delete iListModel;

  1069     iListModel = NULL;

  1070     ResourceL( R_LIST_MODEL_MULTIBLE );

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

  1072     CleanupStack::Pop(); //listModel

  1073 

  1074 // use custom grouper to make own items

  1075     MakeMultibleSortingItemsL( iModifiableItems );

  1076     iTestGrouper->iModifiableItems = &iModifiableItems;

  1077     iTestGrouper->iCopyItems = ETrue;

  1078     iListModel->SetCustomGrouper( iTestGrouper );

  1079 

  1080     return KErrNone;

  1081     }

  1082 

  1083 // ---------------------------------------------------------------------------

  1084 // CContentListingFrameworkTest::ListModelAllFileItemsSetupL

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

  1086 // 

  1087 TInt CContentListingFrameworkTest::ListModelAllFileItemsSetupL( CStifItemParser& aItem )

  1088     {

  1089     ListModelSetupL( aItem );

  1090     iMediaTypeArray.AppendL( ECLFMediaTypeVideo );

  1091     iMediaTypeArray.AppendL( ECLFMediaTypeImage );

  1092     iMediaTypeArray.AppendL( ECLFMediaTypeSound );

  1093     iMediaTypeArray.AppendL( ECLFMediaTypeMusic );

  1094     iMediaTypeArray.AppendL( ECLFMediaTypeStreamingURL );

  1095     iMediaTypeArray.AppendL( ECLFMediaTypePlaylist );

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

  1097     iTestObserver->iWait = &iWait;

  1098     iListModel->RefreshL();

  1099     iWait.Start();

  1100     iItemCount = iListModel->ItemCount();

  1101     

  1102     return KErrNone;

  1103     }

  1104 

  1105 // ---------------------------------------------------------------------------

  1106 // CContentListingFrameworkTest::ListModelSetupFromResourceL

  1107 // ---------------------------------------------------------------------------

  1108 // 

  1109 TInt CContentListingFrameworkTest::ListModelSetupFromResourceL( CStifItemParser& aItem )

  1110     {

  1111     BaseSetupL( aItem );

  1112     CreateModelSetupL( aItem );

  1113     ListModelResourceL();

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

  1115     CleanupStack::Pop(); //listModel

  1116 

  1117     return KErrNone;

  1118     }

  1119 

  1120 // ---------------------------------------------------------------------------

  1121 // CContentListingFrameworkTest::EngineTestSetupL

  1122 // ---------------------------------------------------------------------------

  1123 // 

  1124 TInt CContentListingFrameworkTest::EngineTestSetupL( CStifItemParser& /* aItem */ )

  1125     {

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

  1127     iTestObserver  = new (ELeave) TTestOperationObserver;

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

  1129     iEngine = ContentListingFactory::NewContentListingEngineLC();

  1130     CleanupStack::Pop(); //engine

  1131     iChangedItemObserver = new (ELeave) TTestChangedItemObserver;

  1132     iChangedItemObserver1 = new (ELeave) TTestChangedItemObserver;

  1133     iTestCLFProcessObserver = new (ELeave) TTestCLFProcessObserver;

  1134     iTestCLFProcessObserver1 = new (ELeave) TTestCLFProcessObserver;