/*

* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Implementation of CLF API test 

*

*/

// [INCLUDE FILES] - do not remove

#include <e32svr.h>

#include <s32mem.h>

#include <ecom.h>

#include <StifParser.h>

#include <StifTestEventInterface.h>

#include <Stiftestinterface.h>

#include "ContentListingFrameworkTest.h"

// the header for the tested class

#include <ContentListingFactory.h>

#include <MCLFChangedItemObserver.h>

#include <MCLFContentListingEngine.h>

#include <MCLFCustomGrouper.h>

#include <MCLFCustomSorter.h>

#include <MCLFItem.h>

#include <MCLFItemListModel.h>

#include <MCLFModifiableItem.h>

#include <MCLFOperationObserver.h>

#include <MCLFPostFilter.h>

#include <MCLFSortingStyle.h>

#include <ContentListingFrameworkTest.rsg>

#include <collate.h>

#include <pathInfo.h>

#include <MCLFProcessObserver.h>

#include <CLFContentListingExtended.hrh>

// CONSTANTS

#ifdef __WINSCW__

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

#else

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

#endif

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

_LIT( KTestFileExt, ".txt" );

const TCLFFieldId KMultibleSortingTestField1 = 0x80000001;

const TCLFFieldId KMultibleSortingTestField2 = 0x80000002;

const TCLFFieldId KMultibleSortingTestField3 = 0x80000003;

const TCLFFieldId KMultibleSortingTestField4 = 0x80000004;

const TCLFFieldId KMultibleSortingTestField5 = 0x80000005;

const TCLFFieldId KMultibleSortingTestField6 = 0x80000006;

const TInt KCLFUpdateFoldersSemanticId = 0x1000;

// ---------------------------------------------------------------------------

// class CMGXAsyncCallback

// ---------------------------------------------------------------------------

//

class CCLFAsyncCallback : public CBase

    {

    public:

        ~CCLFAsyncCallback()

            {

            if ( iActiveWait.IsStarted() )

                {

                iActiveWait.AsyncStop();

                }

            }

    public:

        static void AfterL( TTimeIntervalMicroSeconds32 aInterval )

            {

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

            CleanupStack::PushL( self );

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

            CleanupStack::PushL( periodic );

            TCallBack callBack( CallBackL, self );

            TTimeIntervalMicroSeconds32 interval( 1000000 );

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

            self->iActiveWait.Start();

            periodic->Cancel();

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

            }

        static TInt CallBackL( TAny* aObject )

            {

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

            if ( self->iActiveWait.IsStarted() )

                {

                self->iActiveWait.AsyncStop();

                }

            return EFalse;

            }

    private:

        CActiveSchedulerWait iActiveWait;

    };

// ---------------------------------------------------------------------------

// class TTestOperationObserver

// ---------------------------------------------------------------------------

//

class TTestOperationObserver : public MCLFOperationObserver

    {

    public:

        TTestOperationObserver()

            // set invalid values

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

            {}

        void HandleOperationEventL( TCLFOperationEvent aOperationEvent,

                                    TInt aError )

            {

            iError = aError;

            iOperationEvent = aOperationEvent;

            if( iWait &&

                iWait->IsStarted() )

                {

                iWait->AsyncStop();

                }

            }

        TCLFOperationEvent iOperationEvent;

        TInt iError;

        CActiveSchedulerWait* iWait;

    };

// ---------------------------------------------------------------------------

// class TTestCustomSorter

// ---------------------------------------------------------------------------

//

class TTestCustomSorter : public MCLFCustomSorter

    {

    public:

        TTestCustomSorter() : iSortItems( EFalse )

            {

            }

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

            {

            //aItemArray;

            iSortItems = ETrue;

            }

        TBool iSortItems;

    };

// ---------------------------------------------------------------------------

// class TTestCustomGrouper

// ---------------------------------------------------------------------------

//

class TTestCustomGrouper : public MCLFCustomGrouper

    {

    public:

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

            {

            }

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

                          RPointerArray<MCLFItem>& aGroupedList )

            {

            //aSourceList;

            if( iCopyItems )

                {

                TInt count( iModifiableItems->Count() );

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

                    {

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

                    }

                }

            else if( iModifiableItems )

                {

                iModifiableItems->ResetAndDestroy();

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

                    {

                    MCLFModifiableItem* item = ContentListingFactory::NewModifiableItemLC();

                    iModifiableItems->AppendL( item );

                    CleanupStack::Pop(); // item

                    aGroupedList.AppendL( item );

                    }

                }

            }

        TInt iGroupCount;

        TBool iCopyItems;

        RPointerArray<MCLFModifiableItem>* iModifiableItems;

    };

// ---------------------------------------------------------------------------

// class TTestPostFilter

// ---------------------------------------------------------------------------

//

class TTestPostFilter : public MCLFPostFilter

    {

    public:

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

            {

            }

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

                           RPointerArray<MCLFItem>& aFilteredItemList )

            {

            iFilteredCount = 0;

            if( iAllFilter )

                {

                iFilteredCount = aItemList.Count();

                return;

                }

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

                {

                if( i < iShouldFilterCount  )

                    {

                    iFilteredCount++;

                    }

                else

                    {

                    aFilteredItemList.AppendL( aItemList[i] );

                    }

                }

            }

        TInt iShouldFilterCount;

        TBool iAllFilter;

        TInt iFilteredCount;

    };

// ---------------------------------------------------------------------------

// class TTestChangedItemObserver

// ---------------------------------------------------------------------------

//

class TTestChangedItemObserver : public MCLFChangedItemObserver

    {

    public:

        TTestChangedItemObserver()

            : iHandleItemChange( EFalse ),

              iLastError( KErrNone ),

              iChangedArray( NULL ),

              iWait( NULL )      

            {

            }

        void HandleItemChangeL( const TArray<TCLFItemId>& aItemIDArray )

            {

            iHandleItemChange = ETrue;

            if( iChangedArray )

                {

                iChangedArray->Reset();

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

                    {

                    iChangedArray->AppendL( aItemIDArray[i] );

                    }

                }

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

                {

                iWait->AsyncStop();

                }

            }

        void HandleError( TInt aError )

            {

            iLastError = aError;

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

                {

                iWait->AsyncStop();

                }

            }

        TInt iHandleItemChange;

        TInt iLastError;

        RArray<TCLFItemId>* iChangedArray;

        CActiveSchedulerWait* iWait;

    };

// ---------------------------------------------------------------------------

// class TTestCLFProcessObserver

// ---------------------------------------------------------------------------

//

class TTestCLFProcessObserver : public MCLFProcessObserver

    {

    public:

        TTestCLFProcessObserver()

            : iStartEvent( EFalse ), iEndEvent( EFalse )

            {}

        void HandleCLFProcessEventL( TCLFProcessEvent aProcessEvent )

            {

            switch ( aProcessEvent )

                {

                case ECLFUpdateStart:

                    {

                    iStartEvent = ETrue;

                    break;

                    }

                case ECLFUpdateStop:

                    {

                    iEndEvent = ETrue;

                    break;

                    }

                default:

                    {

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

                    }

                }

            }

        void Reset()

            {

            iStartEvent = EFalse;

            iEndEvent = EFalse;

            }

        TBool iStartEvent;

        TBool iEndEvent;

    };

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

    {

    const TInt count( aDataArray.MdcaCount() );

    RBufWriteStream writeStream( aBuffer );

    CleanupClosePushL( writeStream );

    writeStream.WriteInt32L( count );

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

        {

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

        TInt length( des.Length() );

        writeStream.WriteInt32L( length );

        writeStream.WriteL( des, length );

        }

    CleanupStack::PopAndDestroy( &writeStream );

    }

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

// -----------------------------------------------------------------------------

// CContentListingFrameworkTest::Delete

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

// Called from destructor. 

// -----------------------------------------------------------------------------

//

void CContentListingFrameworkTest::Delete() 

    {

    }

// -----------------------------------------------------------------------------

// CCollectionManagerTest::RunMethodL

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

// -----------------------------------------------------------------------------

//

TInt CContentListingFrameworkTest::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        // Copy this line for every implemented function.

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

        // Second is the actual implementation member function. 

        // engine		

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

/**

 * Assistance methods

 */

// ---------------------------------------------------------------------------

// CContentListingFrameworkTest::ResourceL

// ---------------------------------------------------------------------------

//

void CContentListingFrameworkTest::ResourceL( TInt aResourceId )

    {

    delete iDataBuffer;

    iDataBuffer = NULL;

    iDataBuffer = iResourceFile.AllocReadL( aResourceId );

    iResourceReader.SetBuffer( iDataBuffer );

    }

// ---------------------------------------------------------------------------

// CContentListingFrameworkTest::SortingStyleResourceL

// ---------------------------------------------------------------------------

//

void CContentListingFrameworkTest::SortingStyleResourceL()

    {

    ResourceL( R_SORTING_STYLE );

    }

// ---------------------------------------------------------------------------

// CContentListingFrameworkTest::ListModelResourceL

// ---------------------------------------------------------------------------

//

void CContentListingFrameworkTest::ListModelResourceL()

    {

    ResourceL( R_LIST_MODEL );

    }

// ---------------------------------------------------------------------------

// CContentListingFrameworkTest::CreateNewFileL

// ---------------------------------------------------------------------------

//

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

    {

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

    aFileName.Append( KTestFileNameBase );

    TBuf<125> buf;

    buf.Num( aNumber );

    aFileName.Append( buf );

    aFileName.Append( KTestFileExt );

    RFile file;

    BaflUtils::EnsurePathExistsL( iFs, aFileName );

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

    if( error == KErrNone )

        {

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

        }

    file.Close();

    User::LeaveIfError( error );

    }

// ---------------------------------------------------------------------------

// CContentListingFrameworkTest::FindTestFileIdL

// ---------------------------------------------------------------------------

//

TCLFItemId CContentListingFrameworkTest::FindTestFileIdL( TInt aNumber )

    {

    TCLFItemId id( 0 );

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

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

    iTestObserver->iWait = &iWait;

    model->SetWantedMimeTypesL( *iMimeTypeArray );

    model->RefreshL();

    iWait.Start();

    TFileName testFileName( PathInfo::PhoneMemoryRootPath() );

    testFileName.Append( KTestFileNameBase );

    TBuf<125> buf;

    buf.Num( aNumber );

    testFileName.Append( buf );

    testFileName.Append( KTestFileExt );

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

        {

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

        TPtrC fileName;

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

            {

            continue;

            }

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

            {

            id = item.ItemId();

            break;

            }

        }

    CleanupStack::PopAndDestroy(); // model

    return id;

    }

// ---------------------------------------------------------------------------

// CContentListingFrameworkTest::CheckFileNameShortingL

// ---------------------------------------------------------------------------

//

TBool CContentListingFrameworkTest::CheckFileNameShortingL()

    {

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

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

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

        {

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

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

        TPtrC name;

        TPtrC name1;

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

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

            {

            return EFalse;

            }

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

            {

            return EFalse;