/*

* 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:    Unit tests

*

*/

#include "glxlistreconstruction.h"

#include <digia/eunit/eunitmacros.h>

#include <digia/eunit/eunitdecorators.h>

#include <mpxcollectionpath.h>

#include <glxlistdefs.h>

#include <glxpanic.h>

#include "glxmediastaticitemdefs.h"

const TGlxIdSpaceId KListIdSpace( 1 );

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

// Destructor

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

//

template < class _List, class _Reconstruction >

CGlxListTestBase< _List, _Reconstruction >::~CGlxListTestBase() 

    {

    DeleteMembers();

    }

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

// Destructor

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

//

template < class _List, class _Reconstruction >

void CGlxListTestBase< _List, _Reconstruction >::DeleteMembers()

    {

    delete iReconstruction;

    iReconstruction = NULL;

    delete iList;

    iList = NULL;

    iMediaPool.ResetAndDestroy();

    }

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

// Ignore

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

//

template < class _List, class _Reconstruction >

    void CGlxListTestBase< _List, _Reconstruction >::GetRequiredAttributesL( 

        TInt /*aIndex*/, RArray< TMPXAttribute >& /*aAttributes*/ )

    {

    }

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

// Ignore

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

//

template < class _List, class _Reconstruction >

    void CGlxListTestBase< _List, _Reconstruction >

        ::HandleAttributesAvailableL(TInt /*aIndex*/, 

            const RArray< TMPXAttribute >& /*aAttributes*/ )

    {

    }    

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

// Ignore

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

//

template < class _List, class _Reconstruction >

    void CGlxListTestBase< _List, _Reconstruction >

        ::RemoveReference( TInt /*aIndex*/ )

    {

    }

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

// Ignore

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

//

template < class _List, class _Reconstruction >

    void CGlxListTestBase< _List, _Reconstruction >

        ::HandleError( TInt /*aError*/ )

    {

    }

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

// MGlxMediaPool::Media implementation

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

//

template < class _List, class _Reconstruction >

CGlxMedia* CGlxListTestBase< _List, _Reconstruction >

        ::Media( const TGlxIdSpaceId& /*aIdSpaceId*/, const TGlxMediaId& /*aId*/) const  

    {

    return NULL;

    }

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

// Create a list from string

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

//

template < class _List, class _Reconstruction >

    void CGlxListTestBase< _List, _Reconstruction >

        ::CreateListL( const TDesC8& aString )

    {

    CMPXCollectionPath* path = CreatePathLC( aString );

    // Create reconstruction

    CreateReconstructionL();

    // Delete media items

    iMediaPool.ResetAndDestroy();

    // Create list

    delete iList;

    iList = NULL;

    iList = _List::NewL( KListIdSpace, *iReconstruction, *this );

    iReconstruction->SetList( *iList );

    // Set the contents of the old list

    iList->SetContentsL( *path, *this );

    // Reset for test

    iReconstruction->ClearNotifications();

    CleanupStack::PopAndDestroy(path );

    }

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

// Create a list from string

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

//

template < class _List, class _Reconstruction >

    void CGlxListTestBase< _List, _Reconstruction >

        ::CreateListL( const TDesC8& aString, const TDesC8& aLinkedToMedia )

    {

    // Create list

    CreateListL( aString );

    // Link to media

    for ( TInt i = 0; i < aLinkedToMedia.Length(); i++)

        {

        if ( aLinkedToMedia[ i ] == 't' )

            {

            CGlxMedia* media = new (ELeave) CGlxMedia( iList->Item( i ).Id() );

            CleanupStack::PushL( media );

            iMediaPool.AppendL( media );

            CleanupStack::Pop( media );

            media->ReserveUsersL( 1 );

            iList->Item(i).SetMedia( media, *this);

            }

        }

    }

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

// Create a list from string

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

//

template < class _List, class _Reconstruction >

    void CGlxListTestBase< _List, _Reconstruction >

        ::CreateListL( const TDesC8& aString, TBool aStaticItemsEnabled,

            NGlxListTestHelpers::TStaticItemInfo::TData* aStaticItemInfos )

    {

    // Create list

    CreateListL( aString );

    // Add static items, if any

    AddStaticItemsL( aStaticItemInfos );

    // Enable/disable static items

    iList->SetStaticItemsEnabled( aStaticItemsEnabled );

    // Reset for test

    iReconstruction->ClearNotifications();

    }

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

// Create reconstruction

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

//

template < class _List, class _Reconstruction >

    void CGlxListTestBase< _List, _Reconstruction >::CreateReconstructionL()

    {

    delete iReconstruction;

    iReconstruction = NULL;

    iReconstruction = _Reconstruction::NewL();

    }

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

// Test if list equals the list in the string

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

//

template < class _List, class _Reconstruction >

    TBool CGlxListTestBase< _List, _Reconstruction >::Equals( const TDesC8& aNewString )

    {

    ASSERT( iList && iReconstruction );

    // length of list and string must match

    TBool fail = ( iList->Count() != aNewString.Length() );

    for ( TInt i = 0; i < iList->Count(); i++ )

        {

        fail |= ( iList->Item( i ).Id() != TGlxMediaId( aNewString[ i ] ) );

        }

    // Test reconstruction 

    fail |= !iReconstruction->ReconstructionEquals();

    return !fail;

    }

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

// Test if list matches the string and reconstruction matches original

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

//

template < class _List, class _Reconstruction >

TBool CGlxListTestBase< _List, _Reconstruction >::Equals( const TDesC8& aNewString, 

        const TNotification::TData* aNotificationList )

    {

    ASSERT( iList && iReconstruction );

    // Test if list contents match the new intended contents

    TBool fail = !Equals( aNewString );

    // Test notifications and reconstruction match

    fail |= !iReconstruction->NotificationListEquals( aNotificationList );

    return !fail;

    }

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

// Test match

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

//

template < class _List, class _Reconstruction >

TBool CGlxListTestBase< _List, _Reconstruction >

    ::Equals( const TDesC8& aStringWithoutStaticItems, 

        const TDesC8& aStringWithStaticItems, 

            TBool aStaticItemsEnabled, 

                const TNotification::TData* aNotificationList)

    {

    TBool fail = EFalse;

    if ( aStaticItemsEnabled )

        {

        fail |= !Equals( aStringWithStaticItems, aNotificationList );

        }

    else

        {

        fail |= !Equals( aStringWithoutStaticItems, aNotificationList );

        }

    return !fail;

    }

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

// Test if items are linked to media objects correctly

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

//

template < class _List, class _Reconstruction >

    TBool CGlxListTestBase< _List, _Reconstruction >

        ::IsLinkedToMedia( const TDesC8& aAnswers ) const

    {

    TBool fail = EFalse;

    for ( TInt i = 0; i < aAnswers.Length(); i++)

        {

        TBool shouldBeLinked = ( aAnswers[ i ] == 't' ); 

        TBool isLinked = ( iList->Item( i ).Properties() != NULL );

        // Test via not, just in case true is not always exactly 1

        fail |= ( !shouldBeLinked != !isLinked );       

        }

    return !fail;

    }   

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

// Try linking to media item

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

//

/*template < class _List, class _Reconstruction >

    TBool CGlxListTestBase< _List, _Reconstruction >

        ::TryOfferMedia( TChar aId, const TDesC8& aAnswers, TBool aShouldAccept )

    {

    ASSERT( iList );

    CGlxMedia* media = new (ELeave) CGlxMedia( TGlxMediaId( aId ) );

    CleanupStack::PushL( media );

    iMediaPool.AppendL( media );

    CleanupStack::Pop( media );

    media->ReserveUsersL( 1 );

    // Offer media and test acceptance. Compare via not, to since True might be not be 1

    TBool fail = ( !iList->OfferMedia(KListIdSpace,  *media ) != !aShouldAccept );    

    fail |= !IsLinkedToMedia( aAnswers );

    return !fail;

    }*/

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

// Try removing link from media item

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

//

template < class _List, class _Reconstruction >

    TBool CGlxListTestBase< _List, _Reconstruction >

        ::TryRemoveReference( TInt aIndex, const TDesC8& aAnswers )

    {

    ASSERT( iList );

    // Remove reference

    iList->RemoveReference( aIndex );

    TBool fail = !IsLinkedToMedia( aAnswers );

    return !fail;

    }

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

// Test OfferMedia(...)

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

//

/*template < class _List, class _Reconstruction >

    void CGlxListTestBase< _List, _Reconstruction >::TestOfferMediaL()

    {

    // Create the item list

    CreateListL( _L8("abcdefg") );

    EUNIT_ASSERT( IsLinkedToMedia( _L8("fffffff") ) );

    EUNIT_ASSERT( TryOfferMedia( '0', _L8("fffffff"), EFalse ) ); // reject

    EUNIT_ASSERT( TryOfferMedia( 'a', _L8("tffffff"), ETrue ) );  

    EUNIT_ASSERT( TryOfferMedia( 'c', _L8("tftffff"), ETrue ) );  

    EUNIT_ASSERT( TryOfferMedia( 'd', _L8("tfttfff"), ETrue ) );  

    EUNIT_ASSERT( TryOfferMedia( 'g', _L8("tfttfft"), ETrue ) );  

    EUNIT_ASSERT( TryOfferMedia( '1', _L8("tfttfft"), EFalse ) ); // reject

    }*/

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

// Test RemoveReference(...)

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

//

template < class _List, class _Reconstruction >

    void CGlxListTestBase< _List, _Reconstruction >::TestRemoveReferenceL()

    {

    // Create the item list

    CreateListL( _L8("abcdefg"), _L8("tfttfft") );

    EUNIT_ASSERT( IsLinkedToMedia( _L8("tfttfft") ) );

    // Add static items

    // Static items are linked to media

    AddStaticItemL( '0', NGlxListDefs::EInsertFirst );

    AddStaticItemL( '1', NGlxListDefs::EInsertLast );

    EUNIT_ASSERT( IsLinkedToMedia( _L8("ttfttfftt") ) );

    EUNIT_ASSERT( TryRemoveReference( 1, _L8("tffttfftt") ) );

    EUNIT_ASSERT( TryRemoveReference( 3, _L8("tffftfftt") ) );

    EUNIT_ASSERT( TryRemoveReference( 4, _L8("tfffffftt") ) );

    EUNIT_ASSERT( TryRemoveReference( 7, _L8("tffffffft") ) );

    EUNIT_ASSERT_PANIC_DESC( TryRemoveReference( 8, _L8("tffffffft") ), 

                             "Images & videos", EGlxPanicIllegalArgument, 

                             "Incorrect panic" );

    }

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

// Test setting new contents

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

//

template < class _List, class _Reconstruction >

    TBool CGlxListTestBase< _List, _Reconstruction >

        ::SetContentsL( const TDesC8& aString )

    {

    ASSERT( iList );

    // Create source

    CMPXCollectionPath* path = CreatePathLC( aString );

    // Copy source for comparison

    TInt originalIndex = path->Index();

    // Set the source 

    iList->SetContentsL( *path, *this );

    // Test path was not modified

    TBool fail = !( !path->Levels() || originalIndex == path->Index() );

    CleanupStack::PopAndDestroy( path );

    return !fail;

    }

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

// Test reordering contents

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

//

template < class _List, class _Reconstruction >

    TBool CGlxListTestBase< _List, _Reconstruction >

        ::ReorderContentsL( const TDesC8& aString )

    {

    ASSERT( iList );

    // Create source

    CMPXCollectionPath* path = CreatePathLC( aString );

    // Copy source for comparison

    TInt originalIndex = path->Index();

    // Set the source 

    iList->ReorderContentsL( *path, *this );

    // Test path was not modified

    TBool fail = !( !path->Levels() || originalIndex == path->Index() );

    CleanupStack::PopAndDestroy( path );

    return !fail;

    }

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

// Test setting new contents

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

//

template < class _List, class _Reconstruction >

    TBool CGlxListTestBase< _List, _Reconstruction >

        ::TrySetContentsL(  const TDesC8& aOldString, const TDesC8& aNewString )

    {

    // Create the item list

    CreateListL( aOldString );

    // Set the contents

    TBool fail = !SetContentsL( aNewString );

    // Test if list contents match the new intended contents

    fail |= !Equals( aNewString );

    return !fail;

    }

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

// Test setting contents and test notifications also

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

//

template < class _List, class _Reconstruction >

    TBool CGlxListTestBase< _List, _Reconstruction >

        ::TrySetContentsL(  const TDesC8& aOldString, const TDesC8& aNewString, 

            const TNotification::TData* aNotificationList )

    {

    // Test list creation

    TBool fail = !TrySetContentsL( aOldString, aNewString );

    // Test if notification list matches expected

    fail |= !Equals( aNewString, aNotificationList );

    return !fail;

    }

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

// Test setting contents and test notifications also

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

//

template < class _List, class _Reconstruction >

    TBool CGlxListTestBase< _List, _Reconstruction >

        ::TrySetContentsL(  const TDesC8& aOldString, const TDesC8& aNewString, 

            const TDesC8& aNewStringWithStaticItems, 

                const TNotification::TData* aNotificationList, 

                    TBool aStaticItemsEnabled, 

                        NGlxListTestHelpers::TStaticItemInfo::TData* aStaticItemInfos )

    {

    // Create list

    CreateListL( aOldString, aStaticItemsEnabled, aStaticItemInfos );

    TBool fail = !SetContentsL( aNewString );

    fail |= !Equals( aNewString, aNewStringWithStaticItems, aStaticItemsEnabled,

        aNotificationList );

    return !fail;

    }

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

// Test setting contents and test notifications also with and without static items

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

//

template < class _List, class _Reconstruction >

    TBool CGlxListTestBase< _List, _Reconstruction >

        ::TrySetContentsL( const TDesC8& aOldString, const TDesC8& aNewString, 

            const TDesC8& aNewStringWithStaticItems, 

                const TNotification::TData* aNotificationListStaticItemsEnabled,

                    const TNotification::TData* aNotificationListStaticItemsDisabled, 

                        NGlxListTestHelpers::TStaticItemInfo::TData* aStaticItemInfos )

    {

    // without adding static items, while static items are enabled

    TBool fail = !TrySetContentsL( aOldString, aNewString, aNewString,

        aNotificationListStaticItemsDisabled, ETrue, NULL );

    // without adding static items, while static items are disabled

    fail |= !TrySetContentsL( aOldString, aNewString, aNewStringWithStaticItems, 

        aNotificationListStaticItemsDisabled, EFalse, NULL );

    // with adding static items, while static items are enabled

     fail |= !TrySetContentsL( aOldString, aNewString, aNewStringWithStaticItems,

        aNotificationListStaticItemsEnabled, ETrue, aStaticItemInfos );

    // with adding static items, while static items are disabled    

    fail |= !TrySetContentsL( aOldString, aNewString, aNewStringWithStaticItems, 

        aNotificationListStaticItemsDisabled, EFalse, aStaticItemInfos );

    return !fail;

    }

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

// Test Adding a static item

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

//

template < class _List, class _Reconstruction >

    TBool CGlxListTestBase< _List, _Reconstruction >

        ::TryAddStaticItemL( const TDesC8& aInitString, TChar aStaticItemId, 

            NGlxListDefs::TInsertionPosition aInsertPos,

                const TDesC8& aStringAfter,

                    const TNotification::TData* aNotificationList,

                        TBool aStaticItemsEnabled,

                            NGlxListTestHelpers::TStaticItemInfo::TData* aStaticItemInfos )

    {

    CreateListL( aInitString, aStaticItemsEnabled, aStaticItemInfos );

    CGlxMedia* media = new (ELeave) CGlxMedia( TGlxMediaId ( aStaticItemId ) );

    CleanupStack::PushL( media );

    iList->AddStaticItemL( media, aInsertPos );

    CleanupStack::Pop( media );

    TBool fail = !Equals( aInitString, aStringAfter, aStaticItemsEnabled,

        aNotificationList );

    return !fail;

    }

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

// Test Adding a static item

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

//

template < class _List, class _Reconstruction >

    TBool CGlxListTestBase< _List, _Reconstruction >

        ::TryAddStaticItemL( const TDesC8& aInitString, 

            TChar aStaticItemId, NGlxListDefs::TInsertionPosition aInsertPos,