/*

* Copyright (c) 2007 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 

*

*/

// INCLUDES

#include "T_CLFApiModuleTests.h"

#include <s32mem.h> 

#include <eunitmacros.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 <T_ContentListingFramework.rsg>

#include <collate.h>

#include <MCLFProcessObserver.h>

#include <CLFContentListingExtended.hrh>

//CONSTS

#ifdef __WINSCW__

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

#else

_LIT( KTestResourceFile, "c:\\sys\\bin\\T_ContentListingFramework.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 )

            {

            }

        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 );

    }

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

// T_CLFApiModuleTests::NewLC()

// Create the testing class

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

//

T_CLFApiModuleTests* T_CLFApiModuleTests::NewLC()

    {

    T_CLFApiModuleTests* self = new(ELeave) T_CLFApiModuleTests;

    CleanupStack::PushL( self );

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

    // second phase constructor

    self->ConstructL();

    return self;

    }

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

// T_CLFApiModuleTests::ConstructL()

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

//

void T_CLFApiModuleTests::ConstructL()

    {

    CEUnitTestSuiteClass::ConstructL();

    }

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

// T_CLFApiModuleTests::~T_CLFApiModuleTests()

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

//

T_CLFApiModuleTests::~T_CLFApiModuleTests()

    {

    Teardown();

    }

/**

 * Assistance methods

 */

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

// T_CLFApiModuleTests::ResourceL

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

//

void T_CLFApiModuleTests::ResourceL( TInt aResourceId )

    {

    delete iDataBuffer;

    iDataBuffer = NULL;

    iDataBuffer = iResourceFile.AllocReadL( aResourceId );

    iResourceReader.SetBuffer( iDataBuffer );

    }

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

// T_CLFApiModuleTests::SortingStyleResourceL

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

//

void T_CLFApiModuleTests::SortingStyleResourceL()

    {

    ResourceL( R_SORTING_STYLE );

    }

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

// T_CLFApiModuleTests::ListModelResourceL

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

//

void T_CLFApiModuleTests::ListModelResourceL()

    {

    ResourceL( R_LIST_MODEL );

    }

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

// T_CLFApiModuleTests::CreateNewFileL

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

//

void T_CLFApiModuleTests::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 );

    }

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

// T_CLFApiModuleTests::FindTestFileIdL

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

//

TCLFItemId T_CLFApiModuleTests::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;

    }

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

// T_CLFApiModuleTests::CheckFileNameShortingL

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

//

TBool T_CLFApiModuleTests::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;

            }

        }

    return ETrue;

    }

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

// T_CLFApiModuleTests::CheckFileSizeShortingL

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

//

TBool T_CLFApiModuleTests::CheckFileSizeShortingL()

    {

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

        {

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

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

        TInt32 size;

        TInt32 size1;

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

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

            {

            return EFalse;

            }

        if( size < size1 )

            {

            return EFalse;

            }

        }

    return ETrue;

    }

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

// T_CLFApiModuleTests::CheckMultibleSortingShortingL

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

//

TBool T_CLFApiModuleTests::CheckMultibleSortingShortingL()

    {

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

    TInt32 data( 0 );

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

        data != 5 )

        {

        return EFalse;

        }

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

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

        data != 4 )